diff --git a/.bazelrc b/.bazelrc index 4a8696d..9ae2f33 100644 --- a/.bazelrc +++ b/.bazelrc @@ -81,3 +81,45 @@ build:libc++ --action_env=BAZEL_CXXOPTS=-stdlib=libc++ build:libc++ --action_env=BAZEL_LINKLIBS=-l%:libc++.a:-l%:libc++abi.a build:libc++ --action_env=BAZEL_LINKOPTS=-lm:-pthread build:libc++ --define force_libcpp=enabled + +# Android NDK Toolchain Configurations +# Prerequisites: +# 1. Install Android NDK (r25b or later) +# 2. Set ANDROID_NDK_HOME to the NDK installation path +# 3. Add to MODULE.bazel (see bazel/android/ndk.MODULE.bazel): +# android_ndk_repository_extension = use_extension(...) +# use_repo(android_ndk_repository_extension, "androidndk") +# register_toolchains("@androidndk//:all") +build:android_arm64 --platforms=//platform/android:android_arm64 +build:android_arm64 --action_env=ANDROID_NDK_HOME +build:android_arm64 --cxxopt=-D__ANDROID_API__=28 +build:android_arm64 --cpu=aarch64 +build:android_arm64 --linkopt=-lc++_static +build:android_arm64 --linkopt=-lc++abi +build:android_arm64 --extra_toolchains=@androidndk//:all + +build:android_x86_64 --platforms=//platform/android:android_x86_64 +build:android_x86_64 --action_env=ANDROID_NDK_HOME +build:android_x86_64 --cxxopt=-D__ANDROID_API__=28 +build:android_x86_64 --cpu=x86_64 +build:android_x86_64 --linkopt=-lc++_static +build:android_x86_64 --linkopt=-lc++abi +build:android_x86_64 --extra_toolchains=@androidndk//:all + +build:android --config=android_arm64 + +# QNX 8 Toolchain Configurations +# Set QNX_SDP_PATH environment variable or use default ~/qnx800 +build:qnx_aarch64 --platforms=//bazel/toolchains/qnx/platforms:qnx_aarch64 +build:qnx_aarch64 --action_env=QNX_SDP_PATH +build:qnx_aarch64 --define=QNX_SDP_PATH=/home/dave.allison/qnx800 +build:qnx_aarch64 --cxxopt=-D__QNX__ + +build:qnx_x86_64 --platforms=//bazel/toolchains/qnx/platforms:qnx_x86_64 +build:qnx_x86_64 --action_env=QNX_SDP_PATH +build:qnx_x86_64 --define=QNX_SDP_PATH=/home/dave.allison/qnx800 +build:qnx_x86_64 --cxxopt=-D__QNX__ + +# QNX common flags +build:qnx --cxxopt=-std=c++17 +build:qnx --cxxopt=-Wno-sign-compare diff --git a/.github/scripts/android-test.sh b/.github/scripts/android-test.sh new file mode 100755 index 0000000..e6bf59d --- /dev/null +++ b/.github/scripts/android-test.sh @@ -0,0 +1,72 @@ +#!/bin/bash +set -euo pipefail + +# Wait for device to be fully available after emulator boot +adb wait-for-device +adb root +sleep 5 +adb wait-for-device +adb shell "while [[ -z \$(getprop sys.boot_completed) ]]; do sleep 1; done" + +# Create shared memory directory +adb shell "mkdir -p /dev/subspace && chmod 777 /dev/subspace" +adb shell "mkdir -p /data/local/tmp" + +# Collect shared libraries (dereference symlinks from bazel output) +mkdir -p /tmp/android_libs +find bazel-bin/ -name "*.so" -path "*_solib*" -exec cp -L {} /tmp/android_libs/ \; 2>/dev/null || true +find bazel-bin/plugins/ -name "*.so" -exec cp -L {} /tmp/android_libs/ \; 2>/dev/null || true + +if ls /tmp/android_libs/*.so 1>/dev/null 2>&1; then + adb push /tmp/android_libs /data/local/tmp/android_libs +fi + +LIB="LD_LIBRARY_PATH=/data/local/tmp/android_libs" + +# Push test binaries +adb push bazel-bin/server/subspace_server /data/local/tmp/subspace_server +adb push bazel-bin/client/client_test /data/local/tmp/client_test +adb push bazel-bin/client/bridge_test /data/local/tmp/bridge_test +adb push bazel-bin/common/split_buffer_test /data/local/tmp/split_buffer_test +adb push bazel-bin/coro_rpc/test/rpc_test /data/local/tmp/coro_rpc_test +adb push bazel-bin/coro_rpc/server/server_test /data/local/tmp/coro_rpc_server_test +adb push bazel-bin/coro_rpc/client/client_test /data/local/tmp/coro_rpc_client_test +adb push bazel-bin/co20_rpc/test/rpc_test /data/local/tmp/co20_rpc_test +adb push bazel-bin/co20_rpc/server/server_test /data/local/tmp/co20_rpc_server_test +adb push bazel-bin/co20_rpc/client/client_test /data/local/tmp/co20_rpc_client_test +adb push bazel-bin/asio_rpc/test/rpc_test /data/local/tmp/asio_rpc_test +adb push bazel-bin/asio_rpc/server/server_test /data/local/tmp/asio_rpc_server_test +adb push bazel-bin/asio_rpc/client/client_test /data/local/tmp/asio_rpc_client_test + +# Push plugin .so files to relative path expected by tests +adb shell "mkdir -p /data/local/tmp/plugins" +find bazel-bin/plugins/ -name "*.so" -exec adb push {} /data/local/tmp/plugins/ \; 2>/dev/null || true + +# Make binaries executable +adb shell "chmod +x /data/local/tmp/*_test /data/local/tmp/subspace_server" + +echo "=== split_buffer_test ===" +adb shell "cd /data/local/tmp && $LIB ./split_buffer_test" + +echo "=== client_test ===" +adb shell "cd /data/local/tmp && $LIB ./client_test" + +echo "=== bridge_test ===" +adb shell "cd /data/local/tmp && $LIB ./bridge_test" + +echo "=== coro_rpc tests ===" +adb shell "cd /data/local/tmp && $LIB ./coro_rpc_test" +adb shell "cd /data/local/tmp && $LIB ./coro_rpc_server_test" +adb shell "cd /data/local/tmp && $LIB ./coro_rpc_client_test" + +echo "=== co20_rpc tests ===" +adb shell "cd /data/local/tmp && $LIB ./co20_rpc_test" +adb shell "cd /data/local/tmp && $LIB ./co20_rpc_server_test" +adb shell "cd /data/local/tmp && $LIB ./co20_rpc_client_test" + +echo "=== asio_rpc tests ===" +adb shell "cd /data/local/tmp && $LIB ./asio_rpc_test" +adb shell "cd /data/local/tmp && $LIB ./asio_rpc_server_test" +adb shell "cd /data/local/tmp && $LIB ./asio_rpc_client_test" + +echo "=== All Android tests passed ===" diff --git a/.github/scripts/cmake-android-test.sh b/.github/scripts/cmake-android-test.sh new file mode 100755 index 0000000..189ee67 --- /dev/null +++ b/.github/scripts/cmake-android-test.sh @@ -0,0 +1,56 @@ +#!/bin/bash +set -euo pipefail + +BUILD_DIR="build/android" + +# Wait for device to be fully available after emulator boot +adb wait-for-device +adb root +sleep 5 +adb wait-for-device +adb shell "while [[ -z \$(getprop sys.boot_completed) ]]; do sleep 1; done" + +# Create shared memory directory +adb shell "mkdir -p /dev/subspace && chmod 777 /dev/subspace" +adb shell "mkdir -p /data/local/tmp" + +# Push libc++_shared.so from NDK (needed since we built with ANDROID_STL=c++_shared) +NDK_LIBCXX=$(find "$ANDROID_NDK_HOME" -name "libc++_shared.so" -path "*/x86_64-linux-android/*" | head -1) +if [ -n "$NDK_LIBCXX" ]; then + adb push "$NDK_LIBCXX" /data/local/tmp/libc++_shared.so +fi + +LIB="LD_LIBRARY_PATH=/data/local/tmp:/data/local/tmp/plugins" + +# Push test binaries +adb push "$BUILD_DIR/server/subspace_server" /data/local/tmp/subspace_server +adb push "$BUILD_DIR/client/client_test" /data/local/tmp/client_test +adb push "$BUILD_DIR/common/split_buffer_test" /data/local/tmp/split_buffer_test +adb push "$BUILD_DIR/common/common_test" /data/local/tmp/common_test +adb push "$BUILD_DIR/c_client/c_client_test" /data/local/tmp/c_client_test +adb push "$BUILD_DIR/shadow/shadow_test" /data/local/tmp/shadow_test + +# Push plugin .so files +adb shell "mkdir -p /data/local/tmp/plugins" +adb push "$BUILD_DIR/plugins/nop_plugin.so" /data/local/tmp/plugins/ +adb push "$BUILD_DIR/plugins/split_buffer_free_test_plugin.so" /data/local/tmp/plugins/ + +# Make binaries executable +adb shell "chmod +x /data/local/tmp/*_test /data/local/tmp/subspace_server" + +echo "=== common_test ===" +adb shell "cd /data/local/tmp && $LIB ./common_test" + +echo "=== split_buffer_test ===" +adb shell "cd /data/local/tmp && $LIB ./split_buffer_test" + +echo "=== client_test ===" +adb shell "cd /data/local/tmp && $LIB ./client_test" + +echo "=== c_client_test ===" +adb shell "cd /data/local/tmp && $LIB ./c_client_test" + +echo "=== shadow_test ===" +adb shell "cd /data/local/tmp && $LIB ./shadow_test" + +echo "=== All CMake Android tests passed ===" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0b30959..5077a86 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -256,3 +256,110 @@ jobs: - name: Run CMake tests run: ctest --test-dir build/cmake-${{ matrix.build_type }} --output-on-failure + + cmake-android: + name: cmake-android (x86_64) + runs-on: ubuntu-latest + timeout-minutes: 45 + + steps: + - name: Checkout code + uses: actions/checkout@v6 + + - name: Set up Android NDK + run: echo "ANDROID_NDK_HOME=$ANDROID_NDK_LATEST_HOME" >> $GITHUB_ENV + + - name: Configure CMake for Android x86_64 + run: | + cmake -S . -B build/android \ + -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \ + -DANDROID_ABI=x86_64 \ + -DANDROID_PLATFORM=android-28 \ + -DANDROID_STL=c++_shared \ + -DCMAKE_BUILD_TYPE=Release + + - name: Build + run: cmake --build build/android --parallel $(nproc) + + - name: Enable KVM + run: | + echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules + sudo udevadm control --reload-rules + sudo udevadm trigger --name-match=kvm + + - name: Run tests on Android emulator + uses: reactivecircus/android-emulator-runner@v2 + with: + api-level: 30 + target: google_apis + arch: x86_64 + emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none + emulator-boot-timeout: 900 + script: bash .github/scripts/cmake-android-test.sh + + android: + name: android (x86_64) + runs-on: ubuntu-latest + timeout-minutes: 45 + + steps: + - name: Checkout code + uses: actions/checkout@v6 + + - name: Install Bazel + uses: bazel-contrib/setup-bazel@0.18.0 + with: + bazelisk-cache: true + disk-cache: ${{ github.workflow }}-android + repository-cache: true + + - name: Set up Android NDK + run: | + ANDROID_SDK_ROOT="${ANDROID_HOME:-/usr/local/lib/android/sdk}" + # Find the installed NDK version + NDK_VERSION=$(ls "$ANDROID_SDK_ROOT/ndk" | sort -V | tail -1) + echo "ANDROID_NDK_HOME=$ANDROID_SDK_ROOT/ndk/$NDK_VERSION" >> "$GITHUB_ENV" + + - name: Cross-compile for Android x86_64 + run: | + bazel build \ + //server:subspace_server \ + //client:client_test \ + //client:bridge_test \ + //common:split_buffer_test \ + //plugins:nop_plugin.so \ + //plugins:split_buffer_free_test_plugin.so \ + //coro_rpc/test:rpc_test \ + //coro_rpc/server:server_test \ + //coro_rpc/client:client_test \ + //co20_rpc/test:rpc_test \ + //co20_rpc/server:server_test \ + //co20_rpc/client:client_test \ + //asio_rpc/test:rpc_test \ + //asio_rpc/server:server_test \ + //asio_rpc/client:client_test \ + --verbose_failures \ + --config=android_x86_64 + + - name: Enable KVM + run: | + echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules + sudo udevadm control --reload-rules + sudo udevadm trigger --name-match=kvm + + - name: Run tests on Android emulator + uses: reactivecircus/android-emulator-runner@v2 + with: + api-level: 30 + target: google_apis + arch: x86_64 + emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none + emulator-boot-timeout: 900 + script: bash .github/scripts/android-test.sh + + - name: Upload Android test logs + uses: actions/upload-artifact@v7 + if: failure() + with: + name: android-test-logs + path: bazel-testlogs diff --git a/Android.bp b/Android.bp new file mode 100644 index 0000000..7f08d1d --- /dev/null +++ b/Android.bp @@ -0,0 +1,23 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +// Common defaults for all subspace native modules. +cc_defaults { + name: "subspace_defaults", + cflags: [ + "-std=c++17", + "-Wall", + "-Wextra", + "-Wno-missing-field-initializers", + "-Wno-unused-parameter", + ], + target: { + android: { + cflags: ["-DSUBSPACE_ANDROID"], + }, + }, + local_include_dirs: ["."], + stl: "c++_shared", + min_sdk_version: "28", +} diff --git a/BUILD.bazel b/BUILD.bazel index b1e196f..6973a16 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -2,16 +2,29 @@ package(default_visibility = ["//visibility:public"]) config_setting( name = "macos_arm64", - values = {"cpu": "darwin_arm64"}, + constraint_values = [ + "@platforms//os:macos", + "@platforms//cpu:aarch64", + ], ) config_setting( name = "macos_default", - values = {"cpu": "darwin"}, + constraint_values = [ + "@platforms//os:macos", + ], ) config_setting( name = "macos_x86_64", - values = {"cpu": "darwin_x86_64"}, + constraint_values = [ + "@platforms//os:macos", + "@platforms//cpu:x86_64", + ], +) + +config_setting( + name = "android", + constraint_values = ["@platforms//os:android"], ) diff --git a/CMakeLists.txt b/CMakeLists.txt index 81e67b1..289667b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,10 +18,20 @@ set(ABSL_BUILD_TEST_HELPERS ON CACHE INTERNAL "Enable Abseil TESTONLY+PUBLIC hel set(ABSL_USE_EXTERNAL_GOOGLETEST ON CACHE INTERNAL "Use our GoogleTest instead of Abseil downloading its own") set(ABSL_FIND_GOOGLETEST OFF CACHE INTERNAL "Don't find_package(GTest); we provide it via FetchContent") +# When cross-compiling, don't build protoc (we use a host-native one). +if(CMAKE_CROSSCOMPILING) + set(protobuf_BUILD_PROTOC_BINARIES OFF CACHE INTERNAL "Skip building protoc for target") +endif() + # Add common compile options as found in subspace/BUILD # These will apply to all targets in this CMakeLists.txt unless overridden. add_compile_options(-Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter) +# --- Android-specific settings --- +if(ANDROID) + add_compile_definitions(SUBSPACE_ANDROID) +endif() + # --- Apple Silicon (ARM64) specific settings --- # Ensure that CMake targets the correct architecture when building on Apple platforms. # This value will be propagated to sub-dependencies. @@ -97,11 +107,10 @@ FetchContent_Declare( protobuf GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git GIT_TAG v29.5 - # Protobuf's CMake build can be configured to build only necessary components CMAKE_ARGS - -Dprotobuf_BUILD_TESTS=OFF # Explicitly disable building tests to avoid gmock conflicts + -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_BUILD_EXAMPLES=OFF - -Dprotobuf_BUILD_SHARED_LIBS=OFF # Build static libs + -Dprotobuf_BUILD_SHARED_LIBS=OFF -DCMAKE_OSX_ARCHITECTURES="${CMAKE_OSX_ARCHITECTURES}" ) FetchContent_MakeAvailable(protobuf) @@ -124,10 +133,10 @@ if(SUBSPACE_PYTHON) FetchContent_MakeAvailable(pybind11) endif() +#add to get proto/subspace.pb.h working (build dir first so generated files win) +include_directories(${CMAKE_CURRENT_BINARY_DIR}) #add to get */file.h includes working include_directories(${CMAKE_CURRENT_SOURCE_DIR}) -#add to get proto/subspace.pb.h working -include_directories(${CMAKE_CURRENT_BINARY_DIR}) # --- Subspace Tests Target --- # Corresponds to //subspace/tests:tests enable_testing() # Enable CTest for running tests diff --git a/MODULE.bazel b/MODULE.bazel index af7da79..3b9e722 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -11,6 +11,7 @@ bazel_dep(name = "protobuf", version = "33.2") bazel_dep(name = "rules_cc", version = "0.2.17") bazel_dep(name = "rules_pkg", version = "1.0.1") +bazel_dep(name = "rules_android_ndk", version = "0.1.5") bazel_dep(name = "zlib", version = "1.3.1.bcr.5") bazel_dep(name = "coroutines", version = "3.3.2") bazel_dep(name = "cpp_toolbelt", version = "2.1.2") @@ -22,6 +23,12 @@ bazel_dep(name = "boost.coroutine", version = "1.87.0") bazel_dep(name = "rules_shell", version = "0.6.1") bazel_dep(name = "rules_proto", version = "6.0.2") +single_version_override( + module_name = "boost.asio", + patches = ["//patches:boost_asio_android_pthread.patch"], + patch_strip = 1, +) + python = use_extension("@rules_python//python/extensions:python.bzl", "python") python.toolchain( configure_coverage_tool = True, @@ -61,3 +68,10 @@ crate.annotation_select( deps = ["@crates__libc-0.2.182//:libc"], ) use_repo(crate, "crates") + +# Android NDK toolchain for cross-compilation. +android_ndk_repository_extension = use_extension( + "@rules_android_ndk//:extension.bzl", + "android_ndk_repository_extension", +) +use_repo(android_ndk_repository_extension, "androidndk") diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 584568a..835ce52 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -217,6 +217,8 @@ "https://bcr.bazel.build/modules/re2/2025-08-12.bcr.1/source.json": "a8ae7c09533bf67f9f6e5122d884d5741600b09d78dca6fc0f2f8d2ee0c2d957", "https://bcr.bazel.build/modules/rules_android/0.1.1/MODULE.bazel": "48809ab0091b07ad0182defb787c4c5328bd3a278938415c00a7b69b50c4d3a8", "https://bcr.bazel.build/modules/rules_android/0.1.1/source.json": "e6986b41626ee10bdc864937ffb6d6bf275bb5b9c65120e6137d56e6331f089e", + "https://bcr.bazel.build/modules/rules_android_ndk/0.1.5/MODULE.bazel": "ab43d418846060de6396e3f1b515a692e945bcd92a9d4541fddcddc8589004ce", + "https://bcr.bazel.build/modules/rules_android_ndk/0.1.5/source.json": "2950fc77b8e1f1e3874c4e073776f2258ce46926b43c236620c93517fd2e5865", "https://bcr.bazel.build/modules/rules_apple/3.16.0/MODULE.bazel": "0d1caf0b8375942ce98ea944be754a18874041e4e0459401d925577624d3a54a", "https://bcr.bazel.build/modules/rules_apple/4.1.0/MODULE.bazel": "76e10fd4a48038d3fc7c5dc6e63b7063bbf5304a2e3bd42edda6ec660eebea68", "https://bcr.bazel.build/modules/rules_apple/4.1.0/source.json": "8ee81e1708756f81b343a5eb2b2f0b953f1d25c4ab3d4a68dc02754872e80715", @@ -236,6 +238,7 @@ "https://bcr.bazel.build/modules/rules_cc/0.1.5/MODULE.bazel": "88dfc9361e8b5ae1008ac38f7cdfd45ad738e4fa676a3ad67d19204f045a1fd8", "https://bcr.bazel.build/modules/rules_cc/0.2.0/MODULE.bazel": "b5c17f90458caae90d2ccd114c81970062946f49f355610ed89bebf954f5783c", "https://bcr.bazel.build/modules/rules_cc/0.2.13/MODULE.bazel": "eecdd666eda6be16a8d9dc15e44b5c75133405e820f620a234acc4b1fdc5aa37", + "https://bcr.bazel.build/modules/rules_cc/0.2.14/MODULE.bazel": "353c99ed148887ee89c54a17d4100ae7e7e436593d104b668476019023b58df8", "https://bcr.bazel.build/modules/rules_cc/0.2.16/MODULE.bazel": "9242fa89f950c6ef7702801ab53922e99c69b02310c39fb6e62b2bd30df2a1d4", "https://bcr.bazel.build/modules/rules_cc/0.2.17/MODULE.bazel": "1849602c86cb60da8613d2de887f9566a6d354a6df6d7009f9d04a14402f9a84", "https://bcr.bazel.build/modules/rules_cc/0.2.17/source.json": "3832f45d145354049137c0090df04629d9c2b5493dc5c2bf46f1834040133a07", @@ -321,6 +324,19 @@ }, "selectedYankedVersions": {}, "moduleExtensions": { + "@@rules_android_ndk+//:extension.bzl%android_ndk_repository_extension": { + "general": { + "bzlTransitiveDigest": "j+NMXk5/a1vnDypModKL+ToEo/4o7DJeXSFhTfbJ7rI=", + "usagesDigest": "TItR9CHlQeATFb93dsFSm1Q0KP5bwlwGGfzE10p5D/c=", + "recordedInputs": [], + "generatedRepoSpecs": { + "androidndk": { + "repoRuleId": "@@rules_android_ndk+//:rules.bzl%android_ndk_repository", + "attributes": {} + } + } + } + }, "@@rules_kotlin+//src/main/starlark/core/repositories:bzlmod_setup.bzl%rules_kotlin_extensions": { "general": { "bzlTransitiveDigest": "Ga4z8lQy1YQ5rAMy+dOl0dqcCEBnYNCXku8x3YQmDZI=", diff --git a/android/Android.bp b/android/Android.bp new file mode 100644 index 0000000..0a2d076 --- /dev/null +++ b/android/Android.bp @@ -0,0 +1,33 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +// JNI shared library for Android apps. +cc_library_shared { + name: "libsubspace_jni", + defaults: ["subspace_defaults"], + srcs: ["jni/subspace_jni.cc"], + local_include_dirs: [".."], + shared_libs: [ + "libsubspace_client", + "liblog", + ], + static_libs: [ + "libsubspace_common", + "libsubspace_proto", + "libcoroutines", + "libcpp_toolbelt", + ], + header_libs: [ + "jni_headers", + "libabseil-headers", + ], +} + +// Java library for Android apps. +java_library { + name: "subspace-java", + srcs: ["java/com/subspace/*.java"], + required: ["libsubspace_jni"], + sdk_version: "current", +} diff --git a/android/java/com/subspace/SubspaceClient.java b/android/java/com/subspace/SubspaceClient.java new file mode 100644 index 0000000..d4579b9 --- /dev/null +++ b/android/java/com/subspace/SubspaceClient.java @@ -0,0 +1,105 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +package com.subspace; + +/** + * Java wrapper for the Subspace C++ client library. + * + *

Connects to a running Subspace server and creates publishers/subscribers + * for inter-process shared-memory communication. + * + * 

{@code
+ * try (SubspaceClient client = new SubspaceClient("/data/local/tmp/subspace", "myapp")) {
+ *     SubspacePublisher pub = client.createPublisher("/sensor", 1024, 8);
+ *     SubspaceSubscriber sub = client.createSubscriber("/sensor");
+ * }
+ * }
+ */ +public class SubspaceClient implements AutoCloseable { + static { + System.loadLibrary("subspace_jni"); + } + + private long nativeHandle; + + /** + * Connect to the Subspace server. + * + * @param socketPath Unix domain socket path of the server + * @param clientName human-readable name for this client instance + * @throws SubspaceException if the connection fails + */ + public SubspaceClient(String socketPath, String clientName) { + nativeHandle = nativeCreate(socketPath, clientName); + } + + /** Connect to the server on the default Android socket path. */ + public SubspaceClient(String clientName) { + this("/data/local/tmp/subspace", clientName); + } + + /** + * Create a publisher on the given channel. + * + * @param channelName channel name (e.g. "/sensor/imu") + * @param slotSize size of each message slot in bytes + * @param numSlots number of slots in the ring buffer + * @param reliable if true, publisher blocks when all slots are in use + * @return a new publisher + * @throws SubspaceException on failure + */ + public SubspacePublisher createPublisher(String channelName, int slotSize, + int numSlots, boolean reliable) { + checkOpen(); + long pubHandle = nativeCreatePublisher(nativeHandle, channelName, + slotSize, numSlots, reliable); + return new SubspacePublisher(pubHandle); + } + + /** Create a non-reliable publisher with default options. */ + public SubspacePublisher createPublisher(String channelName, int slotSize, + int numSlots) { + return createPublisher(channelName, slotSize, numSlots, false); + } + + /** + * Create a subscriber on the given channel. + * + * @param channelName channel name + * @return a new subscriber + * @throws SubspaceException on failure + */ + public SubspaceSubscriber createSubscriber(String channelName) { + checkOpen(); + long subHandle = nativeCreateSubscriber(nativeHandle, channelName); + return new SubspaceSubscriber(subHandle); + } + + @Override + public void close() { + if (nativeHandle != 0) { + nativeDestroy(nativeHandle); + nativeHandle = 0; + } + } + + private void checkOpen() { + if (nativeHandle == 0) { + throw new IllegalStateException("SubspaceClient is closed"); + } + } + + // Native methods + private static native long nativeCreate(String socketPath, + String clientName); + private static native void nativeDestroy(long handle); + private static native long nativeCreatePublisher(long handle, + String channelName, + int slotSize, + int numSlots, + boolean reliable); + private static native long nativeCreateSubscriber(long handle, + String channelName); +} diff --git a/android/java/com/subspace/SubspaceException.java b/android/java/com/subspace/SubspaceException.java new file mode 100644 index 0000000..8b8c440 --- /dev/null +++ b/android/java/com/subspace/SubspaceException.java @@ -0,0 +1,16 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +package com.subspace; + +/** Thrown when a Subspace native operation fails. */ +public class SubspaceException extends RuntimeException { + public SubspaceException(String message) { + super(message); + } + + public SubspaceException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/android/java/com/subspace/SubspaceMessage.java b/android/java/com/subspace/SubspaceMessage.java new file mode 100644 index 0000000..7d633f4 --- /dev/null +++ b/android/java/com/subspace/SubspaceMessage.java @@ -0,0 +1,59 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +package com.subspace; + +import java.nio.ByteBuffer; + +/** + * A message received from a Subspace channel. + * + *

The {@link #getData()} buffer is a direct {@link ByteBuffer} pointing + * into shared memory. It is only valid until the next call to + * {@link SubspaceSubscriber#readMessage}. + */ +public class SubspaceMessage { + private final ByteBuffer data; + private final long timestamp; + private final long ordinal; + private final int slotId; + private final int length; + + SubspaceMessage(ByteBuffer data, long timestamp, long ordinal, + int slotId, int length) { + this.data = data; + this.timestamp = timestamp; + this.ordinal = ordinal; + this.slotId = slotId; + this.length = length; + } + + /** + * Direct ByteBuffer containing the message payload. Points into shared + * memory; valid until the next read. + */ + public ByteBuffer getData() { + return data; + } + + /** Nanosecond timestamp when the message was published. */ + public long getTimestamp() { + return timestamp; + } + + /** Monotonically increasing sequence number within the channel. */ + public long getOrdinal() { + return ordinal; + } + + /** Internal slot identifier. */ + public int getSlotId() { + return slotId; + } + + /** Size of the message payload in bytes. */ + public int getLength() { + return length; + } +} diff --git a/android/java/com/subspace/SubspacePublisher.java b/android/java/com/subspace/SubspacePublisher.java new file mode 100644 index 0000000..0bebc26 --- /dev/null +++ b/android/java/com/subspace/SubspacePublisher.java @@ -0,0 +1,118 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +package com.subspace; + +import java.nio.ByteBuffer; + +/** + * Publishes messages to a Subspace channel via shared memory. + * + *

Typical usage: + * 

{@code
+ * ByteBuffer buf = publisher.getMessageBuffer(128);
+ * buf.put(myData);
+ * publisher.publishMessage(myData.length);
+ * }
+ * + *

The {@link ByteBuffer} returned by {@link #getMessageBuffer} is a direct + * buffer that points into the shared-memory region. Write your payload into it + * and then call {@link #publishMessage} with the actual size. If you decide + * not to publish, call {@link #cancelPublish} instead. + */ +public class SubspacePublisher implements AutoCloseable { + private long nativeHandle; + + SubspacePublisher(long handle) { + this.nativeHandle = handle; + } + + /** + * Obtain a direct {@link ByteBuffer} backed by the next available message + * slot. If the slot is smaller than {@code maxSize}, the buffer will be + * resized. + * + * @param maxSize requested minimum buffer size; pass -1 to use the current + * slot size + * @return a direct ByteBuffer, or {@code null} if no slot is available + * (reliable publisher with all slots in use) + * @throws SubspaceException on failure + */ + public ByteBuffer getMessageBuffer(int maxSize) { + checkOpen(); + return nativeGetMessageBuffer(nativeHandle, maxSize); + } + + /** Get a message buffer using the default slot size. */ + public ByteBuffer getMessageBuffer() { + return getMessageBuffer(-1); + } + + /** + * Publish the message previously obtained via {@link #getMessageBuffer}. + * + * @param messageSize number of bytes written into the buffer + * @return the ordinal of the published message + * @throws SubspaceException on failure + */ + public long publishMessage(long messageSize) { + checkOpen(); + return nativePublishMessage(nativeHandle, messageSize); + } + + /** + * Cancel a pending publish. Call this instead of {@link #publishMessage} + * if you obtained a buffer but decide not to send it. + */ + public void cancelPublish() { + checkOpen(); + nativeCancelPublish(nativeHandle); + } + + /** + * Return the raw file descriptor that can be polled for writability + * (reliable publisher: triggered when a slot becomes free). + */ + public int getPollFd() { + checkOpen(); + return nativeGetPollFd(nativeHandle); + } + + /** Current slot size in bytes. */ + public int getSlotSize() { + checkOpen(); + return nativeGetSlotSize(nativeHandle); + } + + /** Channel name. */ + public String getName() { + checkOpen(); + return nativeGetName(nativeHandle); + } + + @Override + public void close() { + if (nativeHandle != 0) { + nativeDestroy(nativeHandle); + nativeHandle = 0; + } + } + + private void checkOpen() { + if (nativeHandle == 0) { + throw new IllegalStateException("SubspacePublisher is closed"); + } + } + + // Native methods + private static native ByteBuffer nativeGetMessageBuffer(long handle, + int maxSize); + private static native long nativePublishMessage(long handle, + long messageSize); + private static native void nativeCancelPublish(long handle); + private static native int nativeGetPollFd(long handle); + private static native int nativeGetSlotSize(long handle); + private static native String nativeGetName(long handle); + private static native void nativeDestroy(long handle); +} diff --git a/android/java/com/subspace/SubspaceSubscriber.java b/android/java/com/subspace/SubspaceSubscriber.java new file mode 100644 index 0000000..c61df87 --- /dev/null +++ b/android/java/com/subspace/SubspaceSubscriber.java @@ -0,0 +1,83 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +package com.subspace; + +/** + * Subscribes to messages from a Subspace channel via shared memory. + * + *

Messages are returned as {@link SubspaceMessage} objects containing a + * direct {@link java.nio.ByteBuffer} that points into shared memory (zero + * copy). + * + * 

{@code
+ * SubspaceMessage msg = subscriber.readMessage(false);
+ * if (msg != null) {
+ *     ByteBuffer data = msg.getData();
+ *     // process data...
+ * }
+ * }
+ */ +public class SubspaceSubscriber implements AutoCloseable { + private long nativeHandle; + + SubspaceSubscriber(long handle) { + this.nativeHandle = handle; + } + + /** + * Read the next available message. + * + * @param newest if {@code true}, skip to the most recent message; + * if {@code false}, read the next message in sequence + * @return a {@link SubspaceMessage}, or {@code null} if no message is + * available + * @throws SubspaceException on failure + */ + public SubspaceMessage readMessage(boolean newest) { + checkOpen(); + return nativeReadMessage(nativeHandle, newest); + } + + /** Read the next message in sequence. */ + public SubspaceMessage readMessage() { + return readMessage(false); + } + + /** + * Return the raw file descriptor that can be polled for readability + * (triggered when new messages are available). + */ + public int getPollFd() { + checkOpen(); + return nativeGetPollFd(nativeHandle); + } + + /** Channel name. */ + public String getName() { + checkOpen(); + return nativeGetName(nativeHandle); + } + + @Override + public void close() { + if (nativeHandle != 0) { + nativeDestroy(nativeHandle); + nativeHandle = 0; + } + } + + private void checkOpen() { + if (nativeHandle == 0) { + throw new IllegalStateException("SubspaceSubscriber is closed"); + } + } + + // Native methods + private static native SubspaceMessage nativeReadMessage(long handle, + boolean newest); + private static native int nativeGetPollFd(long handle); + private static native String nativeGetName(long handle); + private static native void nativeDestroy(long handle); +} diff --git a/android/jni/BUILD.bazel b/android/jni/BUILD.bazel new file mode 100644 index 0000000..bd58fca --- /dev/null +++ b/android/jni/BUILD.bazel @@ -0,0 +1,18 @@ +package(default_visibility = ["//visibility:public"]) + +load("@rules_cc//cc:defs.bzl", "cc_binary") + +cc_binary( + name = "libsubspace_jni.so", + srcs = ["subspace_jni.cc"], + deps = [ + "//client:subspace_client", + "//common:subspace_common", + ], + linkopts = select({ + "//:android": ["-llog"], + "//conditions:default": [], + }), + linkshared = True, + target_compatible_with = ["@platforms//os:android"], +) diff --git a/android/jni/subspace_jni.cc b/android/jni/subspace_jni.cc new file mode 100644 index 0000000..3a8f6dc --- /dev/null +++ b/android/jni/subspace_jni.cc @@ -0,0 +1,243 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +#include +#include +#include +#include +#include + +#include "client/client.h" + +#define JNI_METHOD(return_type, class_name, method_name) \ + JNIEXPORT return_type JNICALL \ + Java_com_subspace_##class_name##_##method_name + +namespace { + +struct NativeClient { + std::shared_ptr client; +}; + +struct NativePublisher { + std::shared_ptr client; + std::unique_ptr publisher; +}; + +struct NativeSubscriber { + std::shared_ptr client; + std::unique_ptr subscriber; +}; + +void ThrowException(JNIEnv *env, const char *class_name, const char *msg) { + jclass cls = env->FindClass(class_name); + if (cls != nullptr) { + env->ThrowNew(cls, msg); + env->DeleteLocalRef(cls); + } +} + +void ThrowSubspaceException(JNIEnv *env, const std::string &msg) { + ThrowException(env, "com/subspace/SubspaceException", msg.c_str()); +} + +} // namespace + +extern "C" { + +// --------------------------------------------------------------------------- +// SubspaceClient +// --------------------------------------------------------------------------- + +JNI_METHOD(jlong, SubspaceClient, nativeCreate)(JNIEnv *env, jobject, + jstring socket_path, + jstring client_name) { + const char *socket_cstr = env->GetStringUTFChars(socket_path, nullptr); + const char *name_cstr = env->GetStringUTFChars(client_name, nullptr); + + auto result = subspace::Client::Create(socket_cstr, name_cstr); + env->ReleaseStringUTFChars(socket_path, socket_cstr); + env->ReleaseStringUTFChars(client_name, name_cstr); + + if (!result.ok()) { + ThrowSubspaceException(env, result.status().ToString()); + return 0; + } + + auto *nc = new NativeClient{std::move(*result)}; + return reinterpret_cast(nc); +} + +JNI_METHOD(void, SubspaceClient, nativeDestroy)(JNIEnv *, jobject, + jlong handle) { + delete reinterpret_cast(handle); +} + +JNI_METHOD(jlong, SubspaceClient, nativeCreatePublisher)( + JNIEnv *env, jobject, jlong handle, jstring channel_name, jint slot_size, + jint num_slots, jboolean reliable) { + auto *nc = reinterpret_cast(handle); + const char *name_cstr = env->GetStringUTFChars(channel_name, nullptr); + + subspace::PublisherOptions opts; + opts.SetReliable(reliable); + + auto result = + nc->client->CreatePublisher(name_cstr, slot_size, num_slots, opts); + env->ReleaseStringUTFChars(channel_name, name_cstr); + + if (!result.ok()) { + ThrowSubspaceException(env, result.status().ToString()); + return 0; + } + + auto *np = new NativePublisher{nc->client, + std::make_unique( + std::move(*result))}; + return reinterpret_cast(np); +} + +JNI_METHOD(jlong, SubspaceClient, nativeCreateSubscriber)( + JNIEnv *env, jobject, jlong handle, jstring channel_name) { + auto *nc = reinterpret_cast(handle); + const char *name_cstr = env->GetStringUTFChars(channel_name, nullptr); + + auto result = nc->client->CreateSubscriber(name_cstr); + env->ReleaseStringUTFChars(channel_name, name_cstr); + + if (!result.ok()) { + ThrowSubspaceException(env, result.status().ToString()); + return 0; + } + + auto *ns = new NativeSubscriber{nc->client, + std::make_unique( + std::move(*result))}; + return reinterpret_cast(ns); +} + +// --------------------------------------------------------------------------- +// SubspacePublisher +// --------------------------------------------------------------------------- + +JNI_METHOD(jobject, SubspacePublisher, nativeGetMessageBuffer)( + JNIEnv *env, jobject, jlong handle, jint max_size) { + auto *np = reinterpret_cast(handle); + auto result = np->publisher->GetMessageBuffer(max_size); + if (!result.ok()) { + ThrowSubspaceException(env, result.status().ToString()); + return nullptr; + } + void *buf = *result; + if (buf == nullptr) { + return nullptr; + } + int32_t slot_size = np->publisher->SlotSize(); + return env->NewDirectByteBuffer(buf, max_size > 0 ? max_size : slot_size); +} + +JNI_METHOD(jlong, SubspacePublisher, nativePublishMessage)(JNIEnv *env, + jobject, + jlong handle, + jlong message_size) { + auto *np = reinterpret_cast(handle); + auto result = np->publisher->PublishMessage(message_size); + if (!result.ok()) { + ThrowSubspaceException(env, result.status().ToString()); + return -1; + } + return result->ordinal; +} + +JNI_METHOD(void, SubspacePublisher, nativeCancelPublish)(JNIEnv *, jobject, + jlong handle) { + auto *np = reinterpret_cast(handle); + np->publisher->CancelPublish(); +} + +JNI_METHOD(jint, SubspacePublisher, nativeGetPollFd)(JNIEnv *, jobject, + jlong handle) { + auto *np = reinterpret_cast(handle); + struct pollfd pfd = np->publisher->GetPollFd(); + return pfd.fd; +} + +JNI_METHOD(jint, SubspacePublisher, nativeGetSlotSize)(JNIEnv *, jobject, + jlong handle) { + auto *np = reinterpret_cast(handle); + return np->publisher->SlotSize(); +} + +JNI_METHOD(jstring, SubspacePublisher, nativeGetName)(JNIEnv *env, jobject, + jlong handle) { + auto *np = reinterpret_cast(handle); + return env->NewStringUTF(np->publisher->Name().c_str()); +} + +JNI_METHOD(void, SubspacePublisher, nativeDestroy)(JNIEnv *, jobject, + jlong handle) { + delete reinterpret_cast(handle); +} + +// --------------------------------------------------------------------------- +// SubspaceSubscriber +// --------------------------------------------------------------------------- + +JNI_METHOD(jobject, SubspaceSubscriber, nativeReadMessage)(JNIEnv *env, + jobject, + jlong handle, + jboolean newest) { + auto *ns = reinterpret_cast(handle); + auto mode = newest ? subspace::ReadMode::kReadNewest + : subspace::ReadMode::kReadNext; + auto result = ns->subscriber->ReadMessage(mode); + if (!result.ok()) { + ThrowSubspaceException(env, result.status().ToString()); + return nullptr; + } + const subspace::Message &msg = *result; + if (msg.length == 0) { + return nullptr; + } + + // Build a SubspaceMessage object to return. + jclass msg_class = env->FindClass("com/subspace/SubspaceMessage"); + if (msg_class == nullptr) { + return nullptr; + } + jmethodID ctor = env->GetMethodID(msg_class, "", + "(Ljava/nio/ByteBuffer;JJII)V"); + if (ctor == nullptr) { + return nullptr; + } + + jobject byte_buffer = env->NewDirectByteBuffer( + const_cast(msg.buffer), msg.length); + jobject message = env->NewObject(msg_class, ctor, byte_buffer, + static_cast(msg.timestamp), + static_cast(msg.ordinal), + static_cast(msg.slot_id), + static_cast(msg.length)); + return message; +} + +JNI_METHOD(jint, SubspaceSubscriber, nativeGetPollFd)(JNIEnv *, jobject, + jlong handle) { + auto *ns = reinterpret_cast(handle); + struct pollfd pfd = ns->subscriber->GetPollFd(); + return pfd.fd; +} + +JNI_METHOD(jstring, SubspaceSubscriber, nativeGetName)(JNIEnv *env, jobject, + jlong handle) { + auto *ns = reinterpret_cast(handle); + return env->NewStringUTF(ns->subscriber->Name().c_str()); +} + +JNI_METHOD(void, SubspaceSubscriber, nativeDestroy)(JNIEnv *, jobject, + jlong handle) { + delete reinterpret_cast(handle); +} + +} // extern "C" diff --git a/bazel/android/ndk.MODULE.bazel b/bazel/android/ndk.MODULE.bazel new file mode 100644 index 0000000..a54b896 --- /dev/null +++ b/bazel/android/ndk.MODULE.bazel @@ -0,0 +1,13 @@ +# Android NDK module extension setup. +# +# To enable Android cross-compilation, add the following to a file named +# MODULE.bazel.android in the workspace root (or append to MODULE.bazel): +# +# android_ndk_repository_extension = use_extension( +# "@rules_android_ndk//:extension.bzl", +# "android_ndk_repository_extension", +# ) +# use_repo(android_ndk_repository_extension, "androidndk") +# register_toolchains("@androidndk//:all") +# +# Then set ANDROID_NDK_HOME and build with --config=android. diff --git a/c_client/subspace.cc b/c_client/subspace.cc index 7f47fe0..3352dfc 100644 --- a/c_client/subspace.cc +++ b/c_client/subspace.cc @@ -275,7 +275,12 @@ bool subspace_has_error(void) { // std::shared_ptr. SubspaceClient subspace_create_client(void) { +#if defined(__ANDROID__) + return subspace_create_client_with_socket_and_name( + "/data/local/tmp/subspace", ""); +#else return subspace_create_client_with_socket_and_name("/tmp/subspace", ""); +#endif } SubspaceClient subspace_create_client_with_socket(const char *socket_name) { return subspace_create_client_with_socket_and_name(socket_name, ""); diff --git a/client/Android.bp b/client/Android.bp new file mode 100644 index 0000000..7ec7158 --- /dev/null +++ b/client/Android.bp @@ -0,0 +1,41 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +cc_library_shared { + name: "libsubspace_client", + defaults: ["subspace_defaults"], + srcs: [ + "client.cc", + "client_channel.cc", + "message.cc", + "publisher.cc", + "subscriber.cc", + "checksum.cc", + "arm_crc32.S", + ], + export_include_dirs: ["."], + local_include_dirs: [".."], + static_libs: [ + "libsubspace_common", + "libsubspace_proto", + "libcoroutines", + "libcpp_toolbelt", + ], + shared_libs: [ + "libprotobuf-cpp-lite", + "liblog", + ], + header_libs: [ + "libabseil-headers", + ], + whole_static_libs: [ + "libabsl_status", + "libabsl_statusor", + "libabsl_strings", + "libabsl_str_format_internal", + "libabsl_flat_hash_map", + "libabsl_flat_hash_set", + "libabsl_span", + ], +} diff --git a/client/bridge_test.cc b/client/bridge_test.cc index 1385cae..6d56d26 100644 --- a/client/bridge_test.cc +++ b/client/bridge_test.cc @@ -25,6 +25,12 @@ #include #include +#if defined(__ANDROID__) +#define BRIDGE_TEST_TMP "/data/local/tmp" +#else +#define BRIDGE_TEST_TMP "/tmp" +#endif + ABSL_FLAG(bool, start_server, true, "Start the subspace servers"); ABSL_FLAG(std::string, server, "", "Path to server executable"); ABSL_FLAG(std::string, log_level, "debug", "Log level"); @@ -60,7 +66,7 @@ class BridgeTest : public ::testing::Test { if (!absl::GetFlag(FLAGS_start_server)) { return; } - int lock_fd = ::open("/tmp/subspace_bridge_test_port.lock", + int lock_fd = ::open(BRIDGE_TEST_TMP "/subspace_bridge_test_port.lock", O_CREAT | O_RDWR, 0666); ASSERT_NE(-1, lock_fd); ASSERT_EQ(0, ::flock(lock_fd, LOCK_EX)); @@ -76,7 +82,7 @@ class BridgeTest : public ::testing::Test { } for (int i = 0; i < 2; i++) { printf("Starting Subspace server %d\n", i); - char socket_name_template[] = "/tmp/subspaceXXXXXX"; // NOLINT + char socket_name_template[] = BRIDGE_TEST_TMP "/subspaceXXXXXX"; // NOLINT ::close(mkstemp(&socket_name_template[0])); socket_[i] = &socket_name_template[0]; @@ -159,7 +165,7 @@ class BridgeTest : public ::testing::Test { }; co::CoroutineScheduler BridgeTest::scheduler_[2]; -std::string BridgeTest::socket_[2] = {"/tmp/subspace1", "/tmp/subspace2"}; +std::string BridgeTest::socket_[2] = {BRIDGE_TEST_TMP "/subspace1", BRIDGE_TEST_TMP "/subspace2"}; int BridgeTest::server_pipe_[2][2]; std::unique_ptr BridgeTest::server_[2]; std::thread BridgeTest::server_thread_[2]; diff --git a/client/client.h b/client/client.h index 6a005f8..23a458b 100644 --- a/client/client.h +++ b/client/client.h @@ -33,6 +33,12 @@ #include namespace subspace { +#if defined(__ANDROID__) +constexpr const char *kDefaultServerSocket = "/data/local/tmp/subspace"; +#else +constexpr const char *kDefaultServerSocket = "/tmp/subspace"; +#endif + #ifndef __has_cpp_attribute #define __has_cpp_attribute(attribute) 0 #endif @@ -315,7 +321,7 @@ class ClientImpl : public std::enable_shared_from_this { const std::string &GetName() const { return name_; } // Initialize the client by connecting to the server. - absl::Status Init(const std::string &server_socket = "/tmp/subspace", + absl::Status Init(const std::string &server_socket = kDefaultServerSocket, const std::string &client_name = ""); // Create a publisher for the given channel. If the channel doesn't exit @@ -1409,7 +1415,7 @@ Subscriber::FindMessage(uint64_t timestamp) { class Client { public: static absl::StatusOr> - Create(const std::string &server_socket = "/tmp/subspace", + Create(const std::string &server_socket = kDefaultServerSocket, const std::string &client_name = "", const co::Coroutine *c = nullptr) { auto client = std::make_shared(c); @@ -1427,7 +1433,7 @@ class Client { const std::string &GetName() const { return impl_->GetName(); } // Initialize the client by connecting to the server. - absl::Status Init(const std::string &server_socket = "/tmp/subspace", + absl::Status Init(const std::string &server_socket = kDefaultServerSocket, const std::string &client_name = "") { return impl_->Init(server_socket, client_name); } diff --git a/client/client_channel.cc b/client/client_channel.cc index c4691ad..ce0e4f5 100644 --- a/client/client_channel.cc +++ b/client/client_channel.cc @@ -352,8 +352,13 @@ uint64_t ClientChannel::GetVirtualMemoryUsage() const { static absl::StatusOr OpenSharedMemoryFile(const std::string &filename, int flags) { mode_t old_umask = umask(0); +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + int shm_fd = GetSyscallShim().open_fn(filename.c_str(), flags, + S_IRUSR | S_IWUSR | S_IROTH | S_IWOTH); +#else int shm_fd = GetSyscallShim().shm_open_fn(filename.c_str(), flags, S_IRUSR | S_IWUSR | S_IROTH | S_IWOTH); +#endif umask(old_umask); if (shm_fd == -1) { if (errno == EEXIST) { @@ -371,13 +376,47 @@ absl::StatusOr ClientChannel::CreateBuffer(int buffer_index, size_t size) { std::string filename = BufferSharedMemoryName(buffer_index); -#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + return CreateAndroidBuffer(filename, size); +#elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX return CreateLinuxBuffer(filename, size); #else return CreatePosixBuffer(filename, size); #endif } +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID +absl::StatusOr +ClientChannel::CreateAndroidBuffer(const std::string &filename, size_t size) { + auto &shim = GetSyscallShim(); + // On Android, use regular files in the SHM directory. The file persists so + // that subscribers in other processes can open it by path. + auto shm_fd = OpenSharedMemoryFile(filename, O_RDWR | O_CREAT | O_EXCL); + if (!shm_fd.ok()) { + return shm_fd.status(); + } + if (!shm_fd->Valid()) { + return *shm_fd; + } + + int e = shim.ftruncate_fn(shm_fd->Fd(), off_t(size)); + if (e == -1) { + (void)unlink(filename.c_str()); + return absl::InternalError( + absl::StrFormat("Failed to set length of shared memory %s: %s", + filename, strerror(errno))); + } + + if (shim.chmod_fn(filename.c_str(), 0777) == -1) { + return absl::InternalError( + absl::StrFormat("Failed to change permissions of shared memory %s: %s", + filename, strerror(errno))); + } + + return *shm_fd; +} +#endif + #if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX absl::StatusOr ClientChannel::CreateLinuxBuffer(const std::string &filename, size_t size) { @@ -696,7 +735,9 @@ ClientChannel::OpenSplitBufferSet(size_t buffer_index, size_t full_size, absl::StatusOr ClientChannel::OpenBuffer(int buffer_index) { std::string filename = BufferSharedMemoryName(buffer_index); -#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + return OpenSharedMemoryFile(filename, O_RDWR); +#elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX // Open the shared memory file. return OpenSharedMemoryFile(filename, O_RDWR); #else @@ -724,6 +765,7 @@ ClientChannel::GetBufferSize(toolbelt::FileDescriptor &shm_fd, } return sb.st_size; #else + // On Linux and Android, fstat on the fd gives the correct size. (void)buffer_index; struct stat sb; if (shim.fstat_fn(shm_fd.Fd(), &sb) == -1) { diff --git a/client/client_channel.h b/client/client_channel.h index 6b3b0e1..f92b99f 100644 --- a/client/client_channel.h +++ b/client/client_channel.h @@ -357,7 +357,10 @@ class ClientChannel : public Channel { bool destroy_owned_buffers); void UnmapBufferSet(size_t buffer_index, BufferSet &buffer, bool destroy_owned_buffers); -#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + absl::StatusOr + CreateAndroidBuffer(const std::string &filename, size_t size); +#elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX absl::StatusOr CreateLinuxBuffer(const std::string &filename, size_t size); #elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX diff --git a/client/client_test.cc b/client/client_test.cc index 5815be1..bf85598 100644 --- a/client/client_test.cc +++ b/client/client_test.cc @@ -5358,7 +5358,11 @@ class SplitBufferPluginTest : public ::testing::Test { public: static void SetUpTestSuite() { printf("Starting Subspace server with split-buffer test plugin\n"); +#if defined(__ANDROID__) + char socket_name_template[] = "/data/local/tmp/subspaceXXXXXX"; // NOLINT +#else char socket_name_template[] = "/tmp/subspaceXXXXXX"; // NOLINT +#endif ::close(mkstemp(&socket_name_template[0])); socket_ = &socket_name_template[0]; diff --git a/common/Android.bp b/common/Android.bp new file mode 100644 index 0000000..fab36e5 --- /dev/null +++ b/common/Android.bp @@ -0,0 +1,35 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +cc_library_static { + name: "libsubspace_common", + defaults: ["subspace_defaults"], + srcs: [ + "channel.cc", + "split_buffer.cc", + "system_info.cc", + "syscall_shim.cc", + ], + export_include_dirs: ["."], + local_include_dirs: [".."], + static_libs: [ + "libsubspace_proto", + "libcoroutines", + "libcpp_toolbelt", + ], + shared_libs: [ + "libprotobuf-cpp-lite", + "liblog", + ], + header_libs: [ + "libabseil-headers", + ], + whole_static_libs: [ + "libabsl_status", + "libabsl_statusor", + "libabsl_strings", + "libabsl_str_format_internal", + "libabsl_flat_hash_map", + ], +} diff --git a/common/BUILD.bazel b/common/BUILD.bazel index 1e1a0bd..becdef1 100644 --- a/common/BUILD.bazel +++ b/common/BUILD.bazel @@ -24,6 +24,7 @@ cc_library( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], + "//:android": ["-llog"], "//conditions:default": ["-lrt"], }), deps = [ diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index c5a4ee0..611ff26 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -26,9 +26,15 @@ target_link_libraries(subspace_common PUBLIC toolbelt co subspace_proto - protobuf::libprotobuf # If common code uses protobuf + protobuf::libprotobuf ) +if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT ANDROID) + target_link_libraries(subspace_common PUBLIC rt) +elseif(ANDROID) + target_link_libraries(subspace_common PUBLIC log) +endif() + add_executable(common_test common_test.cc) add_test(NAME common_test COMMAND common_test) target_link_libraries(common_test PUBLIC subspace_common gtest gtest_main) diff --git a/common/channel.cc b/common/channel.cc index 1009d56..2c7343f 100644 --- a/common/channel.cc +++ b/common/channel.cc @@ -23,6 +23,14 @@ namespace subspace { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID +static std::string g_android_shm_dir = kDefaultAndroidShmDir; + +const std::string &GetAndroidShmDir() { return g_android_shm_dir; } + +void SetAndroidShmDir(const std::string &dir) { g_android_shm_dir = dir; } +#endif + // Set this to 1 to print the memory mapping and unmapping calls. #define SHOW_MMAPS 0 @@ -118,7 +126,12 @@ std::string Channel::BufferSharedMemoryName(uint64_t session_id, std::string sanitized_name = absl::StrReplaceAll(ResolvedName(), {{"/", "."}}); -#if defined(__APPLE__) +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + // On Android, use full paths in the configured SHM directory so that + // publishers and subscribers in different processes can open by path. + return absl::StrFormat("%s/subspace_%d_%s_%d", GetAndroidShmDir(), session_id, + sanitized_name, buffer_index); +#elif defined(__APPLE__) // Since you can't actually see any shared memory names in the MacOS // filesystem we need to use /tmp to create a shadow file that is mapped to a // shared memory name. diff --git a/common/channel.h b/common/channel.h index eae16a7..d626c74 100644 --- a/common/channel.h +++ b/common/channel.h @@ -25,9 +25,13 @@ namespace subspace { #define SUBSPACE_SHMEM_MODE_POSIX 1 #define SUBSPACE_SHMEM_MODE_LINUX 2 +#define SUBSPACE_SHMEM_MODE_ANDROID 3 // Change this if you want to use a different shared memory mode. -#if defined(__linux__) +#if defined(__ANDROID__) +// Android does not have /dev/shm; use regular files on a tmpfs-backed dir. +#define SUBSPACE_SHMEM_MODE SUBSPACE_SHMEM_MODE_ANDROID +#elif defined(__linux__) // On Linux we can use /dev/shm directly for shared memory. #define SUBSPACE_SHMEM_MODE SUBSPACE_SHMEM_MODE_LINUX #else @@ -36,6 +40,12 @@ namespace subspace { #define SUBSPACE_SHMEM_MODE SUBSPACE_SHMEM_MODE_POSIX #endif +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID +constexpr const char *kDefaultAndroidShmDir = "/dev/subspace"; +const std::string &GetAndroidShmDir(); +void SetAndroidShmDir(const std::string &dir); +#endif + // Flag for flags field in MessagePrefix. constexpr int kMessageActivate = 1; // This is a reliable activation message. constexpr int kMessageBridged = 2; // This message came from the bridge. diff --git a/common/split_buffer.cc b/common/split_buffer.cc index 93d3c75..5011cb7 100644 --- a/common/split_buffer.cc +++ b/common/split_buffer.cc @@ -5,6 +5,7 @@ #include "common/split_buffer.h" #include "absl/strings/str_format.h" +#include "common/channel.h" #include "common/syscall_shim.h" #include "common/system_info.h" @@ -169,8 +170,14 @@ std::string SplitBufferObjectName(const std::string &shadow_file) { absl::StatusOr CreateSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata) { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + std::string path = GetAndroidShmDir() + "/" + metadata.object_name; + int fd = GetSyscallShim().open_fn(path.c_str(), + O_RDWR | O_CREAT | O_EXCL, 0666); +#else int fd = GetSyscallShim().shm_open_fn(metadata.object_name.c_str(), O_RDWR | O_CREAT | O_EXCL, 0666); +#endif if (fd == -1) { if (errno == EEXIST) { return toolbelt::FileDescriptor(); @@ -186,7 +193,11 @@ CreateSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata) { : PageAlignedSize(metadata.full_size); if (GetSyscallShim().ftruncate_fn(shm_fd.Fd(), static_cast(allocation_size)) == -1) { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + (void)unlink(path.c_str()); +#else (void)GetSyscallShim().shm_unlink_fn(metadata.object_name.c_str()); +#endif return absl::InternalError(absl::StrFormat( "Failed to size split buffer object %s: %s", metadata.object_name, strerror(errno))); @@ -197,8 +208,13 @@ CreateSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata) { absl::StatusOr OpenSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata, int flags) { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + std::string path = GetAndroidShmDir() + "/" + metadata.object_name; + int fd = GetSyscallShim().open_fn(path.c_str(), flags, 0666); +#else int fd = GetSyscallShim().shm_open_fn(metadata.object_name.c_str(), flags, 0666); +#endif if (fd == -1) { return absl::InternalError(absl::StrFormat( "Failed to open split buffer object %s: %s", metadata.object_name, @@ -210,8 +226,13 @@ OpenSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata, int flags) { absl::Status DestroySplitSharedMemoryBuffer( const SplitBufferMetadata &metadata) { absl::Status status = absl::OkStatus(); +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + std::string path = GetAndroidShmDir() + "/" + metadata.object_name; + if (unlink(path.c_str()) == -1 && errno != ENOENT) { +#else if (GetSyscallShim().shm_unlink_fn(metadata.object_name.c_str()) == -1 && errno != ENOENT) { +#endif status = absl::InternalError(absl::StrFormat( "Failed to unlink split buffer object %s: %s", metadata.object_name, strerror(errno))); diff --git a/common/split_buffer_test.cc b/common/split_buffer_test.cc index 0dfa048..8d1e6c3 100644 --- a/common/split_buffer_test.cc +++ b/common/split_buffer_test.cc @@ -16,7 +16,11 @@ namespace subspace { namespace { std::string UniqueShadowFile(const std::string &suffix) { +#if defined(__ANDROID__) + std::string path = "/data/local/tmp/subspace_split_buffer_test_" + suffix + "_XXXXXX"; +#else std::string path = "/tmp/subspace_split_buffer_test_" + suffix + "_XXXXXX"; +#endif std::vector buffer(path.begin(), path.end()); buffer.push_back('\0'); int fd = mkstemp(buffer.data()); diff --git a/common/syscall_shim.cc b/common/syscall_shim.cc index 8ffcb1e..95faad1 100644 --- a/common/syscall_shim.cc +++ b/common/syscall_shim.cc @@ -12,6 +12,7 @@ static int RealOpen(const char *path, int flags, mode_t mode) { return ::open(path, flags, mode); } +#if !defined(__ANDROID__) // Wrapper for ::shm_open which on Linux is variadic (int shm_open(const char*, // int, ...)) and cannot be stored directly as a typed 3-param function pointer. static int RealShmOpen(const char *name, int oflag, mode_t mode) { @@ -19,6 +20,9 @@ static int RealShmOpen(const char *name, int oflag, mode_t mode) { } SyscallShim::SyscallShim() : open_fn(RealOpen), shm_open_fn(RealShmOpen) {} +#else +SyscallShim::SyscallShim() : open_fn(RealOpen) {} +#endif static SyscallShim default_shim; static thread_local SyscallShim *active_shim = &default_shim; diff --git a/common/syscall_shim.h b/common/syscall_shim.h index 40ae117..758e7f0 100644 --- a/common/syscall_shim.h +++ b/common/syscall_shim.h @@ -26,8 +26,10 @@ struct SyscallShim { int (*open_fn)(const char *, int, mode_t) = nullptr; int (*close_fn)(int) = ::close; int (*ftruncate_fn)(int, off_t) = ::ftruncate; +#if !defined(__ANDROID__) int (*shm_open_fn)(const char *, int, mode_t) = nullptr; int (*shm_unlink_fn)(const char *) = ::shm_unlink; +#endif int (*poll_fn)(struct pollfd *, nfds_t, int) = ::poll; int (*stat_fn)(const char *, struct stat *) = ::stat; int (*fstat_fn)(int, struct stat *) = ::fstat; diff --git a/common/syscall_shim_test_helper.h b/common/syscall_shim_test_helper.h index 02cc733..04b7b6d 100644 --- a/common/syscall_shim_test_helper.h +++ b/common/syscall_shim_test_helper.h @@ -40,8 +40,10 @@ struct FailingShim : SyscallShim { int ftruncate_fail_countdown = -1; int ftruncate_errno = EIO; +#if !defined(__ANDROID__) int shm_open_fail_countdown = -1; int shm_open_errno = EACCES; +#endif int poll_fail_countdown = -1; int poll_errno = EINTR; @@ -65,7 +67,9 @@ struct FailingShim : SyscallShim { int munmap_call_count = 0; int open_call_count = 0; int ftruncate_call_count = 0; +#if !defined(__ANDROID__) int shm_open_call_count = 0; +#endif int poll_call_count = 0; int stat_call_count = 0; int fstat_call_count = 0; @@ -78,7 +82,9 @@ struct FailingShim : SyscallShim { munmap_fn = MunmapWrapper; open_fn = OpenWrapper; ftruncate_fn = FtruncateWrapper; +#if !defined(__ANDROID__) shm_open_fn = ShmOpenWrapper; +#endif poll_fn = PollWrapper; stat_fn = StatWrapper; fstat_fn = FstatWrapper; @@ -147,6 +153,7 @@ struct FailingShim : SyscallShim { return ::ftruncate(fd, length); } +#if !defined(__ANDROID__) static int ShmOpenWrapper(const char *name, int oflag, mode_t mode) { auto *s = Self(); s->shm_open_call_count++; @@ -156,6 +163,7 @@ struct FailingShim : SyscallShim { } return ::shm_open(name, oflag, mode); } +#endif static int PollWrapper(struct pollfd *fds, nfds_t nfds, int timeout) { auto *s = Self(); diff --git a/docs/android.md b/docs/android.md new file mode 100644 index 0000000..a62f7da --- /dev/null +++ b/docs/android.md @@ -0,0 +1,263 @@ +# Running Subspace on Android + +This guide covers cross-compiling and running subspace on an Android device or +emulator from a macOS (Apple Silicon) host. + +## Prerequisites + +| Tool | Install | +|------|---------| +| OpenJDK 17 | `brew install openjdk@17` | +| Android CLI tools | `brew install --cask android-commandlinetools` | +| NDK 27 | via `sdkmanager` (see below) | +| ARM64 system image | via `sdkmanager` | + +Install SDK components (accepts licenses automatically): + +```bash +export JAVA_HOME="/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home" +export ANDROID_HOME="/opt/homebrew/share/android-commandlinetools" + +yes | sdkmanager --sdk_root="$ANDROID_HOME" \ + "platform-tools" \ + "platforms;android-34" \ + "ndk;27.0.12077973" \ + "system-images;android-34;google_apis;arm64-v8a" \ + "emulator" +``` + +## Shell Environment (~/.zshrc) + +```bash +export ANDROID_HOME="/opt/homebrew/share/android-commandlinetools" +export ANDROID_NDK_HOME="$ANDROID_HOME/ndk/27.0.12077973" +export PATH="/opt/homebrew/opt/openjdk@17/bin:$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH" +``` + +## Emulator Setup + +Create and boot an ARM64 AVD: + +```bash +avdmanager create avd -n subspace_test \ + -k "system-images;android-34;google_apis;arm64-v8a" \ + --device "pixel_6" + +emulator -avd subspace_test -no-window -no-audio -gpu swiftshader_indirect & +adb wait-for-device +``` + +## Cross-Compiling + +Build the server and tests for Android ARM64: + +```bash +bazelisk build //server:subspace_server //client:client_test \ + --config=android_arm64 +``` + +The `android_arm64` config in `.bazelrc` sets: +- `--platforms=//platform/android:android_arm64` +- `--cpu=aarch64` (prevents legacy macOS config_settings from matching) +- `--linkopt=-lc++_static --linkopt=-lc++abi` (NDK C++ stdlib) +- `--action_env=ANDROID_NDK_HOME` + +## Device Setup + +### Enable root access + +The emulator with `google_apis` images supports `adb root`: + +```bash +adb root +``` + +### Create shared memory directory + +Subspace on Android uses regular files in a tmpfs-backed directory instead of +POSIX `shm_open` (which is unavailable on Android). The default directory is +`/dev/subspace` (defined by `kDefaultAndroidShmDir` in `common/channel.h`). + +```bash +adb shell "mkdir -p /dev/subspace && chmod 777 /dev/subspace" +``` + +Without this directory, any channel creation will fail with a file-not-found +error. + +### Socket path + +The default server socket on Android is `/data/local/tmp/subspace` (defined by +`kDefaultServerSocket` in `client/client.h`). This path is writable without +root. + +## Deploying Binaries + +Bazel produces shared libraries as symlinks in `bazel-bin/_solib_arm64-v8a/`. +You must dereference them before pushing to the device: + +```bash +# Dereference shared library symlinks +rm -rf /tmp/android_libs +mkdir -p /tmp/android_libs +cp -L bazel-bin/_solib_arm64-v8a/*.so /tmp/android_libs/ + +# Push libraries and binaries +adb push /tmp/android_libs/ /data/local/tmp/android_libs/ +adb push bazel-bin/server/subspace_server /data/local/tmp/ +adb push bazel-bin/client/client_test /data/local/tmp/ +adb shell "chmod 755 /data/local/tmp/subspace_server /data/local/tmp/client_test" + +# Push plugins +adb shell "mkdir -p /data/local/tmp/plugins" +adb push bazel-bin/plugins/nop_plugin.so /data/local/tmp/plugins/ +adb push bazel-bin/plugins/split_buffer_free_test_plugin.so /data/local/tmp/plugins/ +``` + +## Running + +### Start the server + +```bash +adb shell "cd /data/local/tmp && ./subspace_server &" +``` + +The server uses the default socket `/data/local/tmp/subspace` and shared memory +directory `/dev/subspace` on Android. No flags are needed for local operation. + +### Run tests + +```bash +adb shell "cd /data/local/tmp && LD_LIBRARY_PATH=/data/local/tmp/android_libs ./client_test" +``` + +`LD_LIBRARY_PATH` is required because the test binary links against shared +libraries that live in the `android_libs/` directory. + +To run a specific test: + +```bash +adb shell "cd /data/local/tmp && LD_LIBRARY_PATH=/data/local/tmp/android_libs \ + ./client_test --gtest_filter='ClientTest.Init'" +``` + +## Android-Specific Implementation Notes + +### Shared Memory + +Android lacks POSIX shared memory (`shm_open`/`shm_unlink`). Subspace uses +`SUBSPACE_SHMEM_MODE_ANDROID` (defined in `common/channel.h`) which: + +- Creates regular files in the `kDefaultAndroidShmDir` (`/dev/subspace`) + directory using `open()`/`mkstemp()` instead of `shm_open()` +- Uses `ftruncate()` + `mmap()` on those files (same as POSIX shm) +- Passes file descriptors between processes via Unix domain sockets + (`SCM_RIGHTS`) +- Cleans up with `unlink()` instead of `shm_unlink()` + +The directory should be on a tmpfs mount for performance. On the emulator, +`/dev/` is typically tmpfs-backed. + +### Split Buffers + +Split buffer shared memory (`common/split_buffer.cc`) also uses the Android shm +directory for its backing files, following the same pattern as regular channel +buffers. + +### Linker Namespaces + +Android enforces linker namespace restrictions. Shared libraries must be in a +directory referenced by `LD_LIBRARY_PATH` or in the same directory as the +executable. The `android_libs/` approach works for `/data/local/tmp/` binaries. + +## CMake Cross-Compilation + +Subspace can be cross-compiled for Android using CMake with the NDK toolchain: + +```bash +export ANDROID_NDK_HOME=/path/to/ndk + +cmake -S . -B build/android \ + -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \ + -DANDROID_ABI=arm64-v8a \ + -DANDROID_PLATFORM=android-28 \ + -DANDROID_STL=c++_shared \ + -DCMAKE_BUILD_TYPE=Release + +cmake --build build/android --parallel +``` + +Pre-generated protobuf files (`proto/subspace.pb.{cc,h}`) are included in the +repository so cross-compilation works without needing a host-native `protoc`. +If `subspace.proto` changes, regenerate them with a native build: + +```bash +cmake -S . -B build/native && cmake --build build/native --target subspace_proto +cp build/native/proto/subspace.pb.{cc,h} proto/ +``` + +## AOSP / Soong (Blueprint) Build + +Subspace provides `Android.bp` files for building as part of an AOSP source +tree using the Soong build system. This is the recommended approach for +integrating subspace into an Android platform image. + +### Directory Layout + +Place the subspace source tree in your AOSP checkout (e.g., +`external/subspace/`). The Blueprint files define these modules: + +| Module | Type | Description | +|--------|------|-------------| +| `libsubspace_common` | static lib | Core channel, shared memory, syscall shim | +| `libsubspace_client` | shared lib | Client API (publisher/subscriber) | +| `libsubspace_server` | static lib | Server implementation | +| `subspace_server` | binary | Standalone server daemon | +| `libsubspace_proto` | static lib | Protobuf message definitions | +| `libsubspace_jni` | shared lib | JNI bindings for Java clients | +| `subspace-java` | java lib | Java client wrapper | + +### External Dependencies + +Subspace requires two external libraries that must also be present in the AOSP +tree: + +1. **coroutines** (`external/coroutines/`) — https://github.com/dallison/coroutines +2. **cpp_toolbelt** (`external/cpp_toolbelt/`) — https://github.com/dallison/cpp_toolbelt + +Example `Android.bp` files for both are provided in `external/coroutines/Android.bp` +and `external/cpp_toolbelt/Android.bp` within this repository. Copy these into +the respective source trees in your AOSP checkout. + +### AOSP Dependencies + +The following modules must be available in the AOSP tree (they are part of +standard AOSP): + +- `libprotobuf-cpp-lite` — Protocol Buffers runtime +- `liblog` — Android logging +- `libdl` — Dynamic linker +- Abseil modules (`libabsl_status`, `libabsl_statusor`, `libabsl_strings`, + `libabsl_str_format_internal`, `libabsl_flat_hash_map`, + `libabsl_flat_hash_set`, `libabsl_flags`, `libabsl_flags_parse`, + `libabsl_span`) +- `libabseil-headers` — Abseil header library +- `jni_headers` — JNI headers (for the JNI module) + +### Building + +```bash +# From your AOSP root: +m subspace_server libsubspace_client libsubspace_jni subspace-java +``` + +### Integration Notes + +- The `subspace_defaults` module in the root `Android.bp` sets C++17 mode, + warning flags, and the `-DSUBSPACE_ANDROID` preprocessor define. +- All modules use `stl: "c++_shared"` and `min_sdk_version: "28"`. +- The server binary can be included in the system partition via + `PRODUCT_PACKAGES += subspace_server` in your device makefile. +- The JNI library and Java wrapper can be included in apps via the standard + AOSP module dependency mechanism. + diff --git a/external/coroutines/Android.bp b/external/coroutines/Android.bp new file mode 100644 index 0000000..07bfe3c --- /dev/null +++ b/external/coroutines/Android.bp @@ -0,0 +1,27 @@ +// Android.bp for the coroutines library (https://github.com/dallison/coroutines). +// Place this file alongside the coroutines source tree at +// external/coroutines/ in your AOSP checkout. + +cc_library_static { + name: "libcoroutines", + srcs: [ + "co/context.S", + "co/coroutine.cc", + ], + export_include_dirs: ["."], + local_include_dirs: ["co"], + cflags: [ + "-std=c++17", + "-Wall", + "-Wno-unused-parameter", + ], + header_libs: [ + "libabseil-headers", + ], + whole_static_libs: [ + "libabsl_flat_hash_map", + "libabsl_flat_hash_set", + ], + stl: "c++_shared", + min_sdk_version: "28", +} diff --git a/external/cpp_toolbelt/Android.bp b/external/cpp_toolbelt/Android.bp new file mode 100644 index 0000000..b80d83d --- /dev/null +++ b/external/cpp_toolbelt/Android.bp @@ -0,0 +1,41 @@ +// Android.bp for cpp_toolbelt (https://github.com/dallison/cpp_toolbelt). +// Place this file alongside the cpp_toolbelt source tree at +// external/cpp_toolbelt/ in your AOSP checkout. + +cc_library_static { + name: "libcpp_toolbelt", + srcs: [ + "toolbelt/color.cc", + "toolbelt/fd.cc", + "toolbelt/hexdump.cc", + "toolbelt/logging.cc", + "toolbelt/payload_buffer.cc", + "toolbelt/pipe.cc", + "toolbelt/sockets.cc", + "toolbelt/table.cc", + "toolbelt/triggerfd.cc", + "toolbelt/stacktrace.cc", + ], + export_include_dirs: ["."], + local_include_dirs: ["toolbelt"], + cflags: [ + "-std=c++17", + "-Wall", + "-Wno-unused-parameter", + ], + static_libs: [ + "libcoroutines", + ], + header_libs: [ + "libabseil-headers", + ], + whole_static_libs: [ + "libabsl_status", + "libabsl_statusor", + "libabsl_strings", + "libabsl_str_format_internal", + "libabsl_span", + ], + stl: "c++_shared", + min_sdk_version: "28", +} diff --git a/manual_tests/BUILD.bazel b/manual_tests/BUILD.bazel index 394118c..71dada2 100644 --- a/manual_tests/BUILD.bazel +++ b/manual_tests/BUILD.bazel @@ -20,7 +20,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) @@ -43,7 +44,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) @@ -66,7 +68,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) @@ -88,7 +91,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) @@ -109,7 +113,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) @@ -130,7 +135,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) @@ -152,6 +158,7 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" ], + "//:android": ["-llog"], + "//conditions:default": ["-lrt"], }), ) diff --git a/patches/BUILD.bazel b/patches/BUILD.bazel new file mode 100644 index 0000000..d518110 --- /dev/null +++ b/patches/BUILD.bazel @@ -0,0 +1 @@ +exports_files(glob(["*.patch"])) diff --git a/patches/boost_asio_android_pthread.patch b/patches/boost_asio_android_pthread.patch new file mode 100644 index 0000000..f50818a --- /dev/null +++ b/patches/boost_asio_android_pthread.patch @@ -0,0 +1,14 @@ +--- a/BUILD.bazel ++++ b/BUILD.bazel +@@ -66,7 +66,8 @@ + linkopts = select({ + "@platforms//os:windows": [ + "-DEFAULTLIB:ws2_32", + "-DEFAULTLIB:mswsock", + ], +- "//conditions:default": [ ++ "@platforms//os:android": [], ++ "//conditions:default": [ + "-lpthread", + ], + }), diff --git a/platform/android/BUILD.bazel b/platform/android/BUILD.bazel new file mode 100644 index 0000000..c610887 --- /dev/null +++ b/platform/android/BUILD.bazel @@ -0,0 +1,17 @@ +package(default_visibility = ["//visibility:public"]) + +platform( + name = "android_arm64", + constraint_values = [ + "@platforms//os:android", + "@platforms//cpu:aarch64", + ], +) + +platform( + name = "android_x86_64", + constraint_values = [ + "@platforms//os:android", + "@platforms//cpu:x86_64", + ], +) diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt index 4a65edb..064c28f 100644 --- a/plugins/CMakeLists.txt +++ b/plugins/CMakeLists.txt @@ -14,15 +14,33 @@ target_include_directories(nop_plugin PRIVATE add_dependencies(nop_plugin subspace_proto) -target_link_libraries(nop_plugin PRIVATE - absl::status - absl::str_format -) - -if(UNIX AND NOT APPLE) +if(ANDROID) + # Android's lld requires all symbols resolved at link time for .so files + target_link_libraries(nop_plugin PRIVATE + libserver + subspace_client + subspace_common + subspace_proto + co + toolbelt + absl::status + absl::str_format + protobuf::libprotobuf + log + ) +elseif(UNIX AND NOT APPLE) + target_link_libraries(nop_plugin PRIVATE + absl::status + absl::str_format + ) target_link_options(nop_plugin PRIVATE "LINKER:--unresolved-symbols=ignore-all" ) +else() + target_link_libraries(nop_plugin PRIVATE + absl::status + absl::str_format + ) endif() set_target_properties(nop_plugin PROPERTIES @@ -46,14 +64,29 @@ target_include_directories(split_buffer_free_test_plugin PRIVATE add_dependencies(split_buffer_free_test_plugin subspace_proto) -target_link_libraries(split_buffer_free_test_plugin PRIVATE - absl::status -) - -if(UNIX AND NOT APPLE) +if(ANDROID) + target_link_libraries(split_buffer_free_test_plugin PRIVATE + libserver + subspace_client + subspace_common + subspace_proto + co + toolbelt + absl::status + protobuf::libprotobuf + log + ) +elseif(UNIX AND NOT APPLE) + target_link_libraries(split_buffer_free_test_plugin PRIVATE + absl::status + ) target_link_options(split_buffer_free_test_plugin PRIVATE "LINKER:--unresolved-symbols=ignore-all" ) +else() + target_link_libraries(split_buffer_free_test_plugin PRIVATE + absl::status + ) endif() set_target_properties(split_buffer_free_test_plugin PROPERTIES diff --git a/proto/Android.bp b/proto/Android.bp new file mode 100644 index 0000000..655b8f7 --- /dev/null +++ b/proto/Android.bp @@ -0,0 +1,17 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +// Generate C++ protobuf sources from subspace.proto. +cc_library_static { + name: "libsubspace_proto", + defaults: ["subspace_defaults"], + srcs: ["subspace.proto"], + proto: { + type: "lite", + canonical_path_from_root: false, + export_proto_headers: true, + }, + shared_libs: ["libprotobuf-cpp-lite"], + export_shared_lib_headers: ["libprotobuf-cpp-lite"], +} diff --git a/proto/CMakeLists.txt b/proto/CMakeLists.txt index dc7f1db..e44b032 100644 --- a/proto/CMakeLists.txt +++ b/proto/CMakeLists.txt @@ -28,19 +28,44 @@ set(SUBSPACE_PROTO_GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}") set(PROTO_SRC "${CMAKE_CURRENT_BINARY_DIR}/subspace.pb.cc") set(PROTO_HDR "${CMAKE_CURRENT_BINARY_DIR}/subspace.pb.h") -# Generate C++ files from the proto file using protoc -# Include both the current source dir and protobuf src dir for well-known types -add_custom_command( - OUTPUT ${PROTO_SRC} ${PROTO_HDR} - COMMAND $ - ARGS --cpp_out=${CMAKE_CURRENT_BINARY_DIR} - --proto_path=${CMAKE_CURRENT_SOURCE_DIR} - --proto_path=${protobuf_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR}/subspace.proto - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/subspace.proto - protobuf::protoc - COMMENT "Generating C++ code from subspace.proto" -) +# When cross-compiling, use pre-generated protobuf files to avoid needing +# a host-native protoc that matches the library version. +if(CMAKE_CROSSCOMPILING) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/subspace.pb.cc") + set(PROTO_SRC "${CMAKE_CURRENT_SOURCE_DIR}/subspace.pb.cc") + set(PROTO_HDR "${CMAKE_CURRENT_SOURCE_DIR}/subspace.pb.h") + message(STATUS "Cross-compiling: using pre-generated protobuf files") + else() + find_program(PROTOC_EXECUTABLE protoc REQUIRED) + message(STATUS "Cross-compiling: using host protoc at ${PROTOC_EXECUTABLE}") + set(PROTO_SRC "${CMAKE_CURRENT_BINARY_DIR}/subspace.pb.cc") + set(PROTO_HDR "${CMAKE_CURRENT_BINARY_DIR}/subspace.pb.h") + add_custom_command( + OUTPUT ${PROTO_SRC} ${PROTO_HDR} + COMMAND ${PROTOC_EXECUTABLE} + ARGS --cpp_out=${CMAKE_CURRENT_BINARY_DIR} + --proto_path=${CMAKE_CURRENT_SOURCE_DIR} + --proto_path=${protobuf_SOURCE_DIR}/src + ${CMAKE_CURRENT_SOURCE_DIR}/subspace.proto + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/subspace.proto + COMMENT "Generating C++ code from subspace.proto (cross-compile)" + ) + endif() +else() + set(PROTO_SRC "${CMAKE_CURRENT_BINARY_DIR}/subspace.pb.cc") + set(PROTO_HDR "${CMAKE_CURRENT_BINARY_DIR}/subspace.pb.h") + add_custom_command( + OUTPUT ${PROTO_SRC} ${PROTO_HDR} + COMMAND $ + ARGS --cpp_out=${CMAKE_CURRENT_BINARY_DIR} + --proto_path=${CMAKE_CURRENT_SOURCE_DIR} + --proto_path=${protobuf_SOURCE_DIR}/src + ${CMAKE_CURRENT_SOURCE_DIR}/subspace.proto + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/subspace.proto + protobuf::protoc + COMMENT "Generating C++ code from subspace.proto" + ) +endif() # Define the subspace_proto library target with the generated sources add_library(subspace_proto STATIC @@ -49,9 +74,12 @@ add_library(subspace_proto STATIC ) -# Add the directory containing the generated headers to the include paths +# Add the directory containing the generated headers to the include paths. +# The parent dir is added so "proto/subspace.pb.h" resolves when using +# pre-generated files from the source tree. target_include_directories(subspace_proto PUBLIC - ${CMAKE_CURRENT_BINARY_DIR} # Headers are generated into the build directory of this subdirectory + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR} ) # Link the generated library against the main Protobuf library diff --git a/proto/subspace.pb.cc b/proto/subspace.pb.cc new file mode 100644 index 0000000..5a09bc9 --- /dev/null +++ b/proto/subspace.pb.cc @@ -0,0 +1,23058 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: subspace.proto +// Protobuf C++ Version: 5.29.5 + +#include "subspace.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace subspace { + template +PROTOBUF_CONSTEXPR VoidMessage::VoidMessage(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct VoidMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR VoidMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~VoidMessageDefaultTypeInternal() {} + union { + VoidMessage _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VoidMessageDefaultTypeInternal _VoidMessage_default_instance_; + +inline constexpr UnregisterClientBufferRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + session_id_{::uint64_t{0u}}, + buffer_index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR UnregisterClientBufferRequest::UnregisterClientBufferRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct UnregisterClientBufferRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR UnregisterClientBufferRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UnregisterClientBufferRequestDefaultTypeInternal() {} + union { + UnregisterClientBufferRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnregisterClientBufferRequestDefaultTypeInternal _UnregisterClientBufferRequest_default_instance_; + +inline constexpr ShadowUpdateChannelOptions::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + has_split_buffer_options_{false}, + use_split_buffers_{false}, + has_max_publishers_{false}, + split_buffers_over_bridge_{false}, + max_publishers_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowUpdateChannelOptions::ShadowUpdateChannelOptions(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowUpdateChannelOptionsDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowUpdateChannelOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowUpdateChannelOptionsDefaultTypeInternal() {} + union { + ShadowUpdateChannelOptions _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowUpdateChannelOptionsDefaultTypeInternal _ShadowUpdateChannelOptions_default_instance_; + +inline constexpr ShadowUnregisterClientBuffer::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + session_id_{::uint64_t{0u}}, + buffer_index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowUnregisterClientBuffer::ShadowUnregisterClientBuffer(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowUnregisterClientBufferDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowUnregisterClientBufferDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowUnregisterClientBufferDefaultTypeInternal() {} + union { + ShadowUnregisterClientBuffer _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowUnregisterClientBufferDefaultTypeInternal _ShadowUnregisterClientBuffer_default_instance_; + +inline constexpr ShadowStateDump::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : session_id_{::uint64_t{0u}}, + num_channels_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowStateDump::ShadowStateDump(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowStateDumpDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowStateDumpDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowStateDumpDefaultTypeInternal() {} + union { + ShadowStateDump _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowStateDumpDefaultTypeInternal _ShadowStateDump_default_instance_; + template +PROTOBUF_CONSTEXPR ShadowStateDone::ShadowStateDone(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct ShadowStateDoneDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowStateDoneDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowStateDoneDefaultTypeInternal() {} + union { + ShadowStateDone _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowStateDoneDefaultTypeInternal _ShadowStateDone_default_instance_; + +inline constexpr ShadowRemoveSubscriber::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + subscriber_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowRemoveSubscriber::ShadowRemoveSubscriber(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowRemoveSubscriberDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowRemoveSubscriberDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowRemoveSubscriberDefaultTypeInternal() {} + union { + ShadowRemoveSubscriber _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowRemoveSubscriberDefaultTypeInternal _ShadowRemoveSubscriber_default_instance_; + +inline constexpr ShadowRemovePublisher::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + publisher_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowRemovePublisher::ShadowRemovePublisher(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowRemovePublisherDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowRemovePublisherDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowRemovePublisherDefaultTypeInternal() {} + union { + ShadowRemovePublisher _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowRemovePublisherDefaultTypeInternal _ShadowRemovePublisher_default_instance_; + +inline constexpr ShadowRemoveChannel::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + channel_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowRemoveChannel::ShadowRemoveChannel(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowRemoveChannelDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowRemoveChannelDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowRemoveChannelDefaultTypeInternal() {} + union { + ShadowRemoveChannel _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowRemoveChannelDefaultTypeInternal _ShadowRemoveChannel_default_instance_; + +inline constexpr ShadowInit::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : session_id_{::uint64_t{0u}}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowInit::ShadowInit(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowInitDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowInitDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowInitDefaultTypeInternal() {} + union { + ShadowInit _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowInitDefaultTypeInternal _ShadowInit_default_instance_; + +inline constexpr ShadowCreateChannel::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + mux_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + channel_id_{0}, + slot_size_{0}, + num_slots_{0}, + is_local_{false}, + is_reliable_{false}, + is_fixed_size_{false}, + has_split_buffer_options_{false}, + checksum_size_{0}, + metadata_size_{0}, + vchan_id_{0}, + use_split_buffers_{false}, + has_max_publishers_{false}, + split_buffers_over_bridge_{false}, + max_publishers_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowCreateChannel::ShadowCreateChannel(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowCreateChannelDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowCreateChannelDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowCreateChannelDefaultTypeInternal() {} + union { + ShadowCreateChannel _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowCreateChannelDefaultTypeInternal _ShadowCreateChannel_default_instance_; + +inline constexpr ShadowAddSubscriber::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + subscriber_id_{0}, + is_reliable_{false}, + is_bridge_{false}, + for_tunnel_{false}, + max_active_messages_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowAddSubscriber::ShadowAddSubscriber(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowAddSubscriberDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowAddSubscriberDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowAddSubscriberDefaultTypeInternal() {} + union { + ShadowAddSubscriber _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowAddSubscriberDefaultTypeInternal _ShadowAddSubscriber_default_instance_; + +inline constexpr ShadowAddPublisher::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + publisher_id_{0}, + is_reliable_{false}, + is_local_{false}, + is_bridge_{false}, + is_fixed_size_{false}, + notify_retirement_{false}, + for_tunnel_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ShadowAddPublisher::ShadowAddPublisher(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowAddPublisherDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowAddPublisherDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowAddPublisherDefaultTypeInternal() {} + union { + ShadowAddPublisher _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowAddPublisherDefaultTypeInternal _ShadowAddPublisher_default_instance_; + +inline constexpr RpcOpenResponse_ResponseChannel::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RpcOpenResponse_ResponseChannel::RpcOpenResponse_ResponseChannel(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcOpenResponse_ResponseChannelDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcOpenResponse_ResponseChannelDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcOpenResponse_ResponseChannelDefaultTypeInternal() {} + union { + RpcOpenResponse_ResponseChannel _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcOpenResponse_ResponseChannelDefaultTypeInternal _RpcOpenResponse_ResponseChannel_default_instance_; + +inline constexpr RpcOpenResponse_RequestChannel::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + slot_size_{0}, + num_slots_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RpcOpenResponse_RequestChannel::RpcOpenResponse_RequestChannel(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcOpenResponse_RequestChannelDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcOpenResponse_RequestChannelDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcOpenResponse_RequestChannelDefaultTypeInternal() {} + union { + RpcOpenResponse_RequestChannel _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcOpenResponse_RequestChannelDefaultTypeInternal _RpcOpenResponse_RequestChannel_default_instance_; + template +PROTOBUF_CONSTEXPR RpcOpenRequest::RpcOpenRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct RpcOpenRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcOpenRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcOpenRequestDefaultTypeInternal() {} + union { + RpcOpenRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcOpenRequestDefaultTypeInternal _RpcOpenRequest_default_instance_; + template +PROTOBUF_CONSTEXPR RpcCloseResponse::RpcCloseResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct RpcCloseResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcCloseResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcCloseResponseDefaultTypeInternal() {} + union { + RpcCloseResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcCloseResponseDefaultTypeInternal _RpcCloseResponse_default_instance_; + +inline constexpr RpcCloseRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : session_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RpcCloseRequest::RpcCloseRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcCloseRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcCloseRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcCloseRequestDefaultTypeInternal() {} + union { + RpcCloseRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcCloseRequestDefaultTypeInternal _RpcCloseRequest_default_instance_; + +inline constexpr RpcCancelRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : session_id_{0}, + request_id_{0}, + client_id_{::uint64_t{0u}}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RpcCancelRequest::RpcCancelRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcCancelRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcCancelRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcCancelRequestDefaultTypeInternal() {} + union { + RpcCancelRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcCancelRequestDefaultTypeInternal _RpcCancelRequest_default_instance_; + +inline constexpr RetirementNotification::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : slot_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RetirementNotification::RetirementNotification(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RetirementNotificationDefaultTypeInternal { + PROTOBUF_CONSTEXPR RetirementNotificationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RetirementNotificationDefaultTypeInternal() {} + union { + RetirementNotification _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RetirementNotificationDefaultTypeInternal _RetirementNotification_default_instance_; + +inline constexpr RemoveSubscriberResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RemoveSubscriberResponse::RemoveSubscriberResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RemoveSubscriberResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR RemoveSubscriberResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RemoveSubscriberResponseDefaultTypeInternal() {} + union { + RemoveSubscriberResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemoveSubscriberResponseDefaultTypeInternal _RemoveSubscriberResponse_default_instance_; + +inline constexpr RemoveSubscriberRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + subscriber_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RemoveSubscriberRequest::RemoveSubscriberRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RemoveSubscriberRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RemoveSubscriberRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RemoveSubscriberRequestDefaultTypeInternal() {} + union { + RemoveSubscriberRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemoveSubscriberRequestDefaultTypeInternal _RemoveSubscriberRequest_default_instance_; + +inline constexpr RemovePublisherResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RemovePublisherResponse::RemovePublisherResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RemovePublisherResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR RemovePublisherResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RemovePublisherResponseDefaultTypeInternal() {} + union { + RemovePublisherResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemovePublisherResponseDefaultTypeInternal _RemovePublisherResponse_default_instance_; + +inline constexpr RemovePublisherRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + publisher_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RemovePublisherRequest::RemovePublisherRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RemovePublisherRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RemovePublisherRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RemovePublisherRequestDefaultTypeInternal() {} + union { + RemovePublisherRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemovePublisherRequestDefaultTypeInternal _RemovePublisherRequest_default_instance_; + +inline constexpr RawMessage::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : data_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RawMessage::RawMessage(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RawMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR RawMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RawMessageDefaultTypeInternal() {} + union { + RawMessage _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RawMessageDefaultTypeInternal _RawMessage_default_instance_; + +inline constexpr InitResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : session_id_{::int64_t{0}}, + scb_fd_index_{0}, + user_id_{0}, + group_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR InitResponse::InitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct InitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR InitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~InitResponseDefaultTypeInternal() {} + union { + InitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InitResponseDefaultTypeInternal _InitResponse_default_instance_; + +inline constexpr InitRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : client_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR InitRequest::InitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct InitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR InitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~InitRequestDefaultTypeInternal() {} + union { + InitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InitRequestDefaultTypeInternal _InitRequest_default_instance_; + +inline constexpr GetTriggersResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : reliable_pub_trigger_fd_indexes_{}, + _reliable_pub_trigger_fd_indexes_cached_byte_size_{0}, + sub_trigger_fd_indexes_{}, + _sub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetTriggersResponse::GetTriggersResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetTriggersResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetTriggersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetTriggersResponseDefaultTypeInternal() {} + union { + GetTriggersResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTriggersResponseDefaultTypeInternal _GetTriggersResponse_default_instance_; + +inline constexpr GetTriggersRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetTriggersRequest::GetTriggersRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetTriggersRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetTriggersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetTriggersRequestDefaultTypeInternal() {} + union { + GetTriggersRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTriggersRequestDefaultTypeInternal _GetTriggersRequest_default_instance_; + +inline constexpr GetChannelStatsRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetChannelStatsRequest::GetChannelStatsRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetChannelStatsRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetChannelStatsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetChannelStatsRequestDefaultTypeInternal() {} + union { + GetChannelStatsRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetChannelStatsRequestDefaultTypeInternal _GetChannelStatsRequest_default_instance_; + +inline constexpr GetChannelInfoRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetChannelInfoRequest::GetChannelInfoRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetChannelInfoRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetChannelInfoRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetChannelInfoRequestDefaultTypeInternal() {} + union { + GetChannelInfoRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetChannelInfoRequestDefaultTypeInternal _GetChannelInfoRequest_default_instance_; + +inline constexpr Discovery_Query::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Discovery_Query::Discovery_Query(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct Discovery_QueryDefaultTypeInternal { + PROTOBUF_CONSTEXPR Discovery_QueryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~Discovery_QueryDefaultTypeInternal() {} + union { + Discovery_Query _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Discovery_QueryDefaultTypeInternal _Discovery_Query_default_instance_; + +inline constexpr Discovery_Advertise::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + reliable_{false}, + notify_retirement_{false}, + split_buffers_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Discovery_Advertise::Discovery_Advertise(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct Discovery_AdvertiseDefaultTypeInternal { + PROTOBUF_CONSTEXPR Discovery_AdvertiseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~Discovery_AdvertiseDefaultTypeInternal() {} + union { + Discovery_Advertise _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Discovery_AdvertiseDefaultTypeInternal _Discovery_Advertise_default_instance_; + +inline constexpr CreateSubscriberResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : reliable_pub_trigger_fd_indexes_{}, + _reliable_pub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + channel_id_{0}, + subscriber_id_{0}, + ccb_fd_index_{0}, + bcb_fd_index_{0}, + trigger_fd_index_{0}, + poll_fd_index_{0}, + slot_size_{0}, + num_slots_{0}, + num_pub_updates_{0}, + vchan_id_{0}, + checksum_size_{0}, + metadata_size_{0}, + use_split_buffers_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CreateSubscriberResponse::CreateSubscriberResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CreateSubscriberResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR CreateSubscriberResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CreateSubscriberResponseDefaultTypeInternal() {} + union { + CreateSubscriberResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreateSubscriberResponseDefaultTypeInternal _CreateSubscriberResponse_default_instance_; + +inline constexpr CreateSubscriberRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + mux_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + subscriber_id_{0}, + is_reliable_{false}, + is_bridge_{false}, + for_tunnel_{false}, + max_active_messages_{0}, + vchan_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CreateSubscriberRequest::CreateSubscriberRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CreateSubscriberRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR CreateSubscriberRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CreateSubscriberRequestDefaultTypeInternal() {} + union { + CreateSubscriberRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreateSubscriberRequestDefaultTypeInternal _CreateSubscriberRequest_default_instance_; + +inline constexpr CreatePublisherResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : sub_trigger_fd_indexes_{}, + _sub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + channel_id_{0}, + publisher_id_{0}, + ccb_fd_index_{0}, + bcb_fd_index_{0}, + pub_poll_fd_index_{0}, + pub_trigger_fd_index_{0}, + num_sub_updates_{0}, + vchan_id_{0}, + retirement_fd_index_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CreatePublisherResponse::CreatePublisherResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CreatePublisherResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR CreatePublisherResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CreatePublisherResponseDefaultTypeInternal() {} + union { + CreatePublisherResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreatePublisherResponseDefaultTypeInternal _CreatePublisherResponse_default_instance_; + +inline constexpr CreatePublisherRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + mux_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + num_slots_{0}, + slot_size_{0}, + is_local_{false}, + is_reliable_{false}, + is_bridge_{false}, + is_fixed_size_{false}, + vchan_id_{0}, + checksum_size_{0}, + metadata_size_{0}, + publisher_id_{0}, + for_tunnel_{false}, + notify_retirement_{false}, + use_split_buffers_{false}, + split_buffers_over_bridge_{false}, + max_publishers_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CreatePublisherRequest::CreatePublisherRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CreatePublisherRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR CreatePublisherRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CreatePublisherRequestDefaultTypeInternal() {} + union { + CreatePublisherRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreatePublisherRequestDefaultTypeInternal _CreatePublisherRequest_default_instance_; + +inline constexpr ChannelStatsProto::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + total_bytes_{::int64_t{0}}, + total_messages_{::int64_t{0}}, + slot_size_{0}, + num_slots_{0}, + num_pubs_{0}, + num_subs_{0}, + max_message_size_{0u}, + total_drops_{0u}, + num_bridge_pubs_{0}, + num_bridge_subs_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ChannelStatsProto::ChannelStatsProto(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ChannelStatsProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChannelStatsProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ChannelStatsProtoDefaultTypeInternal() {} + union { + ChannelStatsProto _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChannelStatsProtoDefaultTypeInternal _ChannelStatsProto_default_instance_; + +inline constexpr ChannelInfoProto::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + type_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + mux_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + slot_size_{0}, + num_slots_{0}, + num_pubs_{0}, + num_subs_{0}, + num_bridge_pubs_{0}, + num_bridge_subs_{0}, + is_reliable_{false}, + is_virtual_{false}, + vchan_id_{0}, + num_tunnel_pubs_{0}, + num_tunnel_subs_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ChannelInfoProto::ChannelInfoProto(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ChannelInfoProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChannelInfoProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ChannelInfoProtoDefaultTypeInternal() {} + union { + ChannelInfoProto _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChannelInfoProtoDefaultTypeInternal _ChannelInfoProto_default_instance_; + +inline constexpr ChannelAddress::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : address_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + port_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ChannelAddress::ChannelAddress(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ChannelAddressDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChannelAddressDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ChannelAddressDefaultTypeInternal() {} + union { + ChannelAddress _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChannelAddressDefaultTypeInternal _ChannelAddress_default_instance_; + +inline constexpr Subscribed::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + retirement_socket_{nullptr}, + slot_size_{0}, + num_slots_{0}, + checksum_size_{0}, + reliable_{false}, + notify_retirement_{false}, + split_buffers_{false}, + split_buffers_over_bridge_{false}, + metadata_size_{0} {} + +template +PROTOBUF_CONSTEXPR Subscribed::Subscribed(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SubscribedDefaultTypeInternal { + PROTOBUF_CONSTEXPR SubscribedDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SubscribedDefaultTypeInternal() {} + union { + Subscribed _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscribedDefaultTypeInternal _Subscribed_default_instance_; + +inline constexpr Statistics::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channels_{}, + server_id_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + timestamp_{::int64_t{0}}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Statistics::Statistics(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct StatisticsDefaultTypeInternal { + PROTOBUF_CONSTEXPR StatisticsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StatisticsDefaultTypeInternal() {} + union { + Statistics _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatisticsDefaultTypeInternal _Statistics_default_instance_; + +inline constexpr RpcServerRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : client_id_{::uint64_t{0u}}, + request_id_{0}, + request_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR RpcServerRequest::RpcServerRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcServerRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcServerRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcServerRequestDefaultTypeInternal() {} + union { + RpcServerRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcServerRequestDefaultTypeInternal _RpcServerRequest_default_instance_; + +inline constexpr RpcResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + result_{nullptr}, + session_id_{0}, + request_id_{0}, + client_id_{::uint64_t{0u}}, + is_last_{false}, + is_cancelled_{false} {} + +template +PROTOBUF_CONSTEXPR RpcResponse::RpcResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcResponseDefaultTypeInternal() {} + union { + RpcResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcResponseDefaultTypeInternal _RpcResponse_default_instance_; + +inline constexpr RpcRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + argument_{nullptr}, + method_{0}, + session_id_{0}, + client_id_{::uint64_t{0u}}, + request_id_{0} {} + +template +PROTOBUF_CONSTEXPR RpcRequest::RpcRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcRequestDefaultTypeInternal() {} + union { + RpcRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcRequestDefaultTypeInternal _RpcRequest_default_instance_; + +inline constexpr RpcOpenResponse_Method::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + cancel_channel_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + request_channel_{nullptr}, + response_channel_{nullptr}, + id_{0} {} + +template +PROTOBUF_CONSTEXPR RpcOpenResponse_Method::RpcOpenResponse_Method(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcOpenResponse_MethodDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcOpenResponse_MethodDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcOpenResponse_MethodDefaultTypeInternal() {} + union { + RpcOpenResponse_Method _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcOpenResponse_MethodDefaultTypeInternal _RpcOpenResponse_Method_default_instance_; + +inline constexpr GetChannelStatsResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channels_{}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetChannelStatsResponse::GetChannelStatsResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetChannelStatsResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetChannelStatsResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetChannelStatsResponseDefaultTypeInternal() {} + union { + GetChannelStatsResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetChannelStatsResponseDefaultTypeInternal _GetChannelStatsResponse_default_instance_; + +inline constexpr GetChannelInfoResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channels_{}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetChannelInfoResponse::GetChannelInfoResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetChannelInfoResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetChannelInfoResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetChannelInfoResponseDefaultTypeInternal() {} + union { + GetChannelInfoResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetChannelInfoResponseDefaultTypeInternal _GetChannelInfoResponse_default_instance_; + +inline constexpr Discovery_Subscribe::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + receiver_{nullptr}, + reliable_{false} {} + +template +PROTOBUF_CONSTEXPR Discovery_Subscribe::Discovery_Subscribe(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct Discovery_SubscribeDefaultTypeInternal { + PROTOBUF_CONSTEXPR Discovery_SubscribeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~Discovery_SubscribeDefaultTypeInternal() {} + union { + Discovery_Subscribe _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Discovery_SubscribeDefaultTypeInternal _Discovery_Subscribe_default_instance_; + +inline constexpr ClientBufferHandleMetadataProto::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + channel_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + shadow_file_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + object_name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + allocator_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + pool_id_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + allocator_metadata_{nullptr}, + session_id_{::uint64_t{0u}}, + buffer_index_{0u}, + slot_id_{0u}, + full_size_{::uint64_t{0u}}, + allocation_size_{::uint64_t{0u}}, + handle_{::uint64_t{0u}}, + is_prefix_{false}, + cache_enabled_{false}, + alignment_{0u} {} + +template +PROTOBUF_CONSTEXPR ClientBufferHandleMetadataProto::ClientBufferHandleMetadataProto(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ClientBufferHandleMetadataProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientBufferHandleMetadataProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientBufferHandleMetadataProtoDefaultTypeInternal() {} + union { + ClientBufferHandleMetadataProto _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientBufferHandleMetadataProtoDefaultTypeInternal _ClientBufferHandleMetadataProto_default_instance_; + +inline constexpr ChannelDirectory::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : channels_{}, + server_id_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ChannelDirectory::ChannelDirectory(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ChannelDirectoryDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChannelDirectoryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ChannelDirectoryDefaultTypeInternal() {} + union { + ChannelDirectory _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChannelDirectoryDefaultTypeInternal _ChannelDirectory_default_instance_; + +inline constexpr ShadowRegisterClientBuffer::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + metadata_{nullptr} {} + +template +PROTOBUF_CONSTEXPR ShadowRegisterClientBuffer::ShadowRegisterClientBuffer(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowRegisterClientBufferDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowRegisterClientBufferDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowRegisterClientBufferDefaultTypeInternal() {} + union { + ShadowRegisterClientBuffer _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowRegisterClientBufferDefaultTypeInternal _ShadowRegisterClientBuffer_default_instance_; + +inline constexpr RpcOpenResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : methods_{}, + client_id_{::uint64_t{0u}}, + session_id_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RpcOpenResponse::RpcOpenResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcOpenResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcOpenResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcOpenResponseDefaultTypeInternal() {} + union { + RpcOpenResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcOpenResponseDefaultTypeInternal _RpcOpenResponse_default_instance_; + +inline constexpr Response::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : response_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR Response::Response(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ResponseDefaultTypeInternal() {} + union { + Response _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResponseDefaultTypeInternal _Response_default_instance_; + +inline constexpr RegisterClientBufferRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + metadata_{nullptr} {} + +template +PROTOBUF_CONSTEXPR RegisterClientBufferRequest::RegisterClientBufferRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RegisterClientBufferRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RegisterClientBufferRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RegisterClientBufferRequestDefaultTypeInternal() {} + union { + RegisterClientBufferRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisterClientBufferRequestDefaultTypeInternal _RegisterClientBufferRequest_default_instance_; + +inline constexpr Discovery::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : server_id_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + port_{0}, + data_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR Discovery::Discovery(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct DiscoveryDefaultTypeInternal { + PROTOBUF_CONSTEXPR DiscoveryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~DiscoveryDefaultTypeInternal() {} + union { + Discovery _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DiscoveryDefaultTypeInternal _Discovery_default_instance_; + +inline constexpr ShadowEvent::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : event_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR ShadowEvent::ShadowEvent(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ShadowEventDefaultTypeInternal { + PROTOBUF_CONSTEXPR ShadowEventDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ShadowEventDefaultTypeInternal() {} + union { + ShadowEvent _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShadowEventDefaultTypeInternal _ShadowEvent_default_instance_; + +inline constexpr RpcServerResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + client_id_{::uint64_t{0u}}, + request_id_{0}, + response_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR RpcServerResponse::RpcServerResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RpcServerResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR RpcServerResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RpcServerResponseDefaultTypeInternal() {} + union { + RpcServerResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcServerResponseDefaultTypeInternal _RpcServerResponse_default_instance_; + +inline constexpr Request::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : request_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR Request::Request(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RequestDefaultTypeInternal() {} + union { + Request _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestDefaultTypeInternal _Request_default_instance_; +} // namespace subspace +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_subspace_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_subspace_2eproto = nullptr; +const ::uint32_t + TableStruct_subspace_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::InitRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::InitRequest, _impl_.client_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::InitResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::InitResponse, _impl_.scb_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::InitResponse, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::InitResponse, _impl_.user_id_), + PROTOBUF_FIELD_OFFSET(::subspace::InitResponse, _impl_.group_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.is_local_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.is_reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.is_bridge_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.is_fixed_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.for_tunnel_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.mux_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.vchan_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.notify_retirement_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.checksum_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.metadata_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.publisher_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.use_split_buffers_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.max_publishers_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherRequest, _impl_.split_buffers_over_bridge_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.channel_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.publisher_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.ccb_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.bcb_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.pub_poll_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.pub_trigger_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.sub_trigger_fd_indexes_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.num_sub_updates_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.vchan_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.retirement_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreatePublisherResponse, _impl_.retirement_fd_indexes_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.subscriber_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.is_reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.is_bridge_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.max_active_messages_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.for_tunnel_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.mux_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberRequest, _impl_.vchan_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.channel_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.subscriber_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.ccb_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.bcb_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.trigger_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.poll_fd_index_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.reliable_pub_trigger_fd_indexes_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.num_pub_updates_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.vchan_id_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.retirement_fd_indexes_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.checksum_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.metadata_size_), + PROTOBUF_FIELD_OFFSET(::subspace::CreateSubscriberResponse, _impl_.use_split_buffers_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersRequest, _impl_.channel_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersResponse, _impl_.reliable_pub_trigger_fd_indexes_), + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersResponse, _impl_.sub_trigger_fd_indexes_), + PROTOBUF_FIELD_OFFSET(::subspace::GetTriggersResponse, _impl_.retirement_fd_indexes_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RemovePublisherRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RemovePublisherRequest, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::RemovePublisherRequest, _impl_.publisher_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RemovePublisherResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RemovePublisherResponse, _impl_.error_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RemoveSubscriberRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RemoveSubscriberRequest, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::RemoveSubscriberRequest, _impl_.subscriber_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RemoveSubscriberResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RemoveSubscriberResponse, _impl_.error_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelInfoRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelInfoRequest, _impl_.channel_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelInfoResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelInfoResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelInfoResponse, _impl_.channels_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelStatsRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelStatsRequest, _impl_.channel_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelStatsResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelStatsResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::GetChannelStatsResponse, _impl_.channels_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.buffer_index_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.slot_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.is_prefix_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.full_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.allocation_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.handle_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.shadow_file_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.object_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.allocator_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.pool_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.cache_enabled_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.alignment_), + PROTOBUF_FIELD_OFFSET(::subspace::ClientBufferHandleMetadataProto, _impl_.allocator_metadata_), + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::subspace::RegisterClientBufferRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::RegisterClientBufferRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RegisterClientBufferRequest, _impl_.metadata_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::UnregisterClientBufferRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::UnregisterClientBufferRequest, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::UnregisterClientBufferRequest, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::UnregisterClientBufferRequest, _impl_.buffer_index_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::Request, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::subspace::Request, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::subspace::Request, _impl_.request_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::Response, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::subspace::Response, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::subspace::Response, _impl_.response_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_pubs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_subs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_bridge_pubs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_bridge_subs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.is_reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_tunnel_pubs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.num_tunnel_subs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.is_virtual_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.vchan_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelInfoProto, _impl_.mux_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ChannelDirectory, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ChannelDirectory, _impl_.server_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelDirectory, _impl_.channels_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.total_bytes_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.total_messages_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.num_pubs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.num_subs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.max_message_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.total_drops_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.num_bridge_pubs_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelStatsProto, _impl_.num_bridge_subs_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::Statistics, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::Statistics, _impl_.server_id_), + PROTOBUF_FIELD_OFFSET(::subspace::Statistics, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::subspace::Statistics, _impl_.channels_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ChannelAddress, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ChannelAddress, _impl_.address_), + PROTOBUF_FIELD_OFFSET(::subspace::ChannelAddress, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.notify_retirement_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.retirement_socket_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.checksum_size_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.metadata_size_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.split_buffers_), + PROTOBUF_FIELD_OFFSET(::subspace::Subscribed, _impl_.split_buffers_over_bridge_), + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 0, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RetirementNotification, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RetirementNotification, _impl_.slot_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Query, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Query, _impl_.channel_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Advertise, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Advertise, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Advertise, _impl_.reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Advertise, _impl_.notify_retirement_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Advertise, _impl_.split_buffers_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Subscribe, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Subscribe, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Subscribe, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Subscribe, _impl_.receiver_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery_Subscribe, _impl_.reliable_), + ~0u, + 0, + ~0u, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::Discovery, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::subspace::Discovery, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::Discovery, _impl_.server_id_), + PROTOBUF_FIELD_OFFSET(::subspace::Discovery, _impl_.port_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::subspace::Discovery, _impl_.data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_RequestChannel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_RequestChannel, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_RequestChannel, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_RequestChannel, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_RequestChannel, _impl_.type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_ResponseChannel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_ResponseChannel, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_ResponseChannel, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _impl_.request_channel_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _impl_.response_channel_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse_Method, _impl_.cancel_channel_), + ~0u, + ~0u, + 0, + 1, + ~0u, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse, _impl_.methods_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcOpenResponse, _impl_.client_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcCloseRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcCloseRequest, _impl_.session_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcCloseResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerRequest, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerRequest, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerRequest, _impl_.client_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerRequest, _impl_.request_id_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerRequest, _impl_.request_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _impl_.client_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _impl_.request_id_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _impl_.response_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _impl_.method_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _impl_.argument_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _impl_.request_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcRequest, _impl_.client_id_), + ~0u, + 0, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.result_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.request_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.client_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.is_last_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcResponse, _impl_.is_cancelled_), + ~0u, + 0, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RpcCancelRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RpcCancelRequest, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcCancelRequest, _impl_.request_id_), + PROTOBUF_FIELD_OFFSET(::subspace::RpcCancelRequest, _impl_.client_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::RawMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::RawMessage, _impl_.data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::VoidMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowEvent, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowEvent, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::subspace::ShadowEvent, _impl_.event_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowInit, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowInit, _impl_.session_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.channel_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.slot_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.num_slots_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.is_local_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.is_reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.is_fixed_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.checksum_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.metadata_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.mux_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.vchan_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.has_split_buffer_options_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.use_split_buffers_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.has_max_publishers_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.max_publishers_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowCreateChannel, _impl_.split_buffers_over_bridge_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemoveChannel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemoveChannel, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemoveChannel, _impl_.channel_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.publisher_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.is_reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.is_local_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.is_bridge_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.is_fixed_size_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.notify_retirement_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddPublisher, _impl_.for_tunnel_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemovePublisher, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemovePublisher, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemovePublisher, _impl_.publisher_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _impl_.subscriber_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _impl_.is_reliable_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _impl_.is_bridge_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _impl_.max_active_messages_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowAddSubscriber, _impl_.for_tunnel_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemoveSubscriber, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemoveSubscriber, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRemoveSubscriber, _impl_.subscriber_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowStateDump, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowStateDump, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowStateDump, _impl_.num_channels_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowStateDone, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRegisterClientBuffer, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRegisterClientBuffer, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowRegisterClientBuffer, _impl_.metadata_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUnregisterClientBuffer, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUnregisterClientBuffer, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUnregisterClientBuffer, _impl_.session_id_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUnregisterClientBuffer, _impl_.buffer_index_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _impl_.channel_name_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _impl_.has_split_buffer_options_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _impl_.use_split_buffers_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _impl_.has_max_publishers_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _impl_.max_publishers_), + PROTOBUF_FIELD_OFFSET(::subspace::ShadowUpdateChannelOptions, _impl_.split_buffers_over_bridge_), +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::subspace::InitRequest)}, + {9, -1, -1, sizeof(::subspace::InitResponse)}, + {21, -1, -1, sizeof(::subspace::CreatePublisherRequest)}, + {47, -1, -1, sizeof(::subspace::CreatePublisherResponse)}, + {68, -1, -1, sizeof(::subspace::CreateSubscriberRequest)}, + {85, -1, -1, sizeof(::subspace::CreateSubscriberResponse)}, + {110, -1, -1, sizeof(::subspace::GetTriggersRequest)}, + {119, -1, -1, sizeof(::subspace::GetTriggersResponse)}, + {131, -1, -1, sizeof(::subspace::RemovePublisherRequest)}, + {141, -1, -1, sizeof(::subspace::RemovePublisherResponse)}, + {150, -1, -1, sizeof(::subspace::RemoveSubscriberRequest)}, + {160, -1, -1, sizeof(::subspace::RemoveSubscriberResponse)}, + {169, -1, -1, sizeof(::subspace::GetChannelInfoRequest)}, + {178, -1, -1, sizeof(::subspace::GetChannelInfoResponse)}, + {188, -1, -1, sizeof(::subspace::GetChannelStatsRequest)}, + {197, -1, -1, sizeof(::subspace::GetChannelStatsResponse)}, + {207, 230, -1, sizeof(::subspace::ClientBufferHandleMetadataProto)}, + {245, 254, -1, sizeof(::subspace::RegisterClientBufferRequest)}, + {255, -1, -1, sizeof(::subspace::UnregisterClientBufferRequest)}, + {266, -1, -1, sizeof(::subspace::Request)}, + {285, -1, -1, sizeof(::subspace::Response)}, + {302, -1, -1, sizeof(::subspace::ChannelInfoProto)}, + {324, -1, -1, sizeof(::subspace::ChannelDirectory)}, + {334, -1, -1, sizeof(::subspace::ChannelStatsProto)}, + {353, -1, -1, sizeof(::subspace::Statistics)}, + {364, -1, -1, sizeof(::subspace::ChannelAddress)}, + {374, 392, -1, sizeof(::subspace::Subscribed)}, + {402, -1, -1, sizeof(::subspace::RetirementNotification)}, + {411, -1, -1, sizeof(::subspace::Discovery_Query)}, + {420, -1, -1, sizeof(::subspace::Discovery_Advertise)}, + {432, 443, -1, sizeof(::subspace::Discovery_Subscribe)}, + {446, -1, -1, sizeof(::subspace::Discovery)}, + {460, -1, -1, sizeof(::subspace::RpcOpenRequest)}, + {468, -1, -1, sizeof(::subspace::RpcOpenResponse_RequestChannel)}, + {480, -1, -1, sizeof(::subspace::RpcOpenResponse_ResponseChannel)}, + {490, 503, -1, sizeof(::subspace::RpcOpenResponse_Method)}, + {508, -1, -1, sizeof(::subspace::RpcOpenResponse)}, + {519, -1, -1, sizeof(::subspace::RpcCloseRequest)}, + {528, -1, -1, sizeof(::subspace::RpcCloseResponse)}, + {536, -1, -1, sizeof(::subspace::RpcServerRequest)}, + {549, -1, -1, sizeof(::subspace::RpcServerResponse)}, + {563, 576, -1, sizeof(::subspace::RpcRequest)}, + {581, 596, -1, sizeof(::subspace::RpcResponse)}, + {603, -1, -1, sizeof(::subspace::RpcCancelRequest)}, + {614, -1, -1, sizeof(::subspace::RawMessage)}, + {623, -1, -1, sizeof(::subspace::VoidMessage)}, + {631, -1, -1, sizeof(::subspace::ShadowEvent)}, + {652, -1, -1, sizeof(::subspace::ShadowInit)}, + {661, -1, -1, sizeof(::subspace::ShadowCreateChannel)}, + {686, -1, -1, sizeof(::subspace::ShadowRemoveChannel)}, + {696, -1, -1, sizeof(::subspace::ShadowAddPublisher)}, + {712, -1, -1, sizeof(::subspace::ShadowRemovePublisher)}, + {722, -1, -1, sizeof(::subspace::ShadowAddSubscriber)}, + {736, -1, -1, sizeof(::subspace::ShadowRemoveSubscriber)}, + {746, -1, -1, sizeof(::subspace::ShadowStateDump)}, + {756, -1, -1, sizeof(::subspace::ShadowStateDone)}, + {764, 773, -1, sizeof(::subspace::ShadowRegisterClientBuffer)}, + {774, -1, -1, sizeof(::subspace::ShadowUnregisterClientBuffer)}, + {785, -1, -1, sizeof(::subspace::ShadowUpdateChannelOptions)}, +}; +static const ::_pb::Message* const file_default_instances[] = { + &::subspace::_InitRequest_default_instance_._instance, + &::subspace::_InitResponse_default_instance_._instance, + &::subspace::_CreatePublisherRequest_default_instance_._instance, + &::subspace::_CreatePublisherResponse_default_instance_._instance, + &::subspace::_CreateSubscriberRequest_default_instance_._instance, + &::subspace::_CreateSubscriberResponse_default_instance_._instance, + &::subspace::_GetTriggersRequest_default_instance_._instance, + &::subspace::_GetTriggersResponse_default_instance_._instance, + &::subspace::_RemovePublisherRequest_default_instance_._instance, + &::subspace::_RemovePublisherResponse_default_instance_._instance, + &::subspace::_RemoveSubscriberRequest_default_instance_._instance, + &::subspace::_RemoveSubscriberResponse_default_instance_._instance, + &::subspace::_GetChannelInfoRequest_default_instance_._instance, + &::subspace::_GetChannelInfoResponse_default_instance_._instance, + &::subspace::_GetChannelStatsRequest_default_instance_._instance, + &::subspace::_GetChannelStatsResponse_default_instance_._instance, + &::subspace::_ClientBufferHandleMetadataProto_default_instance_._instance, + &::subspace::_RegisterClientBufferRequest_default_instance_._instance, + &::subspace::_UnregisterClientBufferRequest_default_instance_._instance, + &::subspace::_Request_default_instance_._instance, + &::subspace::_Response_default_instance_._instance, + &::subspace::_ChannelInfoProto_default_instance_._instance, + &::subspace::_ChannelDirectory_default_instance_._instance, + &::subspace::_ChannelStatsProto_default_instance_._instance, + &::subspace::_Statistics_default_instance_._instance, + &::subspace::_ChannelAddress_default_instance_._instance, + &::subspace::_Subscribed_default_instance_._instance, + &::subspace::_RetirementNotification_default_instance_._instance, + &::subspace::_Discovery_Query_default_instance_._instance, + &::subspace::_Discovery_Advertise_default_instance_._instance, + &::subspace::_Discovery_Subscribe_default_instance_._instance, + &::subspace::_Discovery_default_instance_._instance, + &::subspace::_RpcOpenRequest_default_instance_._instance, + &::subspace::_RpcOpenResponse_RequestChannel_default_instance_._instance, + &::subspace::_RpcOpenResponse_ResponseChannel_default_instance_._instance, + &::subspace::_RpcOpenResponse_Method_default_instance_._instance, + &::subspace::_RpcOpenResponse_default_instance_._instance, + &::subspace::_RpcCloseRequest_default_instance_._instance, + &::subspace::_RpcCloseResponse_default_instance_._instance, + &::subspace::_RpcServerRequest_default_instance_._instance, + &::subspace::_RpcServerResponse_default_instance_._instance, + &::subspace::_RpcRequest_default_instance_._instance, + &::subspace::_RpcResponse_default_instance_._instance, + &::subspace::_RpcCancelRequest_default_instance_._instance, + &::subspace::_RawMessage_default_instance_._instance, + &::subspace::_VoidMessage_default_instance_._instance, + &::subspace::_ShadowEvent_default_instance_._instance, + &::subspace::_ShadowInit_default_instance_._instance, + &::subspace::_ShadowCreateChannel_default_instance_._instance, + &::subspace::_ShadowRemoveChannel_default_instance_._instance, + &::subspace::_ShadowAddPublisher_default_instance_._instance, + &::subspace::_ShadowRemovePublisher_default_instance_._instance, + &::subspace::_ShadowAddSubscriber_default_instance_._instance, + &::subspace::_ShadowRemoveSubscriber_default_instance_._instance, + &::subspace::_ShadowStateDump_default_instance_._instance, + &::subspace::_ShadowStateDone_default_instance_._instance, + &::subspace::_ShadowRegisterClientBuffer_default_instance_._instance, + &::subspace::_ShadowUnregisterClientBuffer_default_instance_._instance, + &::subspace::_ShadowUpdateChannelOptions_default_instance_._instance, +}; +const char descriptor_table_protodef_subspace_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\016subspace.proto\022\010subspace\032\031google/proto" + "buf/any.proto\"\"\n\013InitRequest\022\023\n\013client_n" + "ame\030\001 \001(\t\"[\n\014InitResponse\022\024\n\014scb_fd_inde" + "x\030\001 \001(\005\022\022\n\nsession_id\030\002 \001(\003\022\017\n\007user_id\030\003" + " \001(\005\022\020\n\010group_id\030\004 \001(\005\"\233\003\n\026CreatePublish" + "erRequest\022\024\n\014channel_name\030\001 \001(\t\022\021\n\tnum_s" + "lots\030\002 \001(\005\022\021\n\tslot_size\030\003 \001(\005\022\020\n\010is_loca" + "l\030\004 \001(\010\022\023\n\013is_reliable\030\005 \001(\010\022\021\n\tis_bridg" + "e\030\006 \001(\010\022\014\n\004type\030\007 \001(\014\022\025\n\ris_fixed_size\030\010" + " \001(\010\022\022\n\nfor_tunnel\030\017 \001(\010\022\013\n\003mux\030\t \001(\t\022\020\n" + "\010vchan_id\030\n \001(\005\022\031\n\021notify_retirement\030\013 \001" + "(\010\022\025\n\rchecksum_size\030\014 \001(\005\022\025\n\rmetadata_si" + "ze\030\r \001(\005\022\024\n\014publisher_id\030\016 \001(\005\022\031\n\021use_sp" + "lit_buffers\030\020 \001(\010\022\026\n\016max_publishers\030\021 \001(" + "\005\022!\n\031split_buffers_over_bridge\030\022 \001(\010\"\314\002\n" + "\027CreatePublisherResponse\022\r\n\005error\030\001 \001(\t\022" + "\022\n\nchannel_id\030\002 \001(\005\022\024\n\014publisher_id\030\003 \001(" + "\005\022\024\n\014ccb_fd_index\030\004 \001(\005\022\024\n\014bcb_fd_index\030" + "\005 \001(\005\022\031\n\021pub_poll_fd_index\030\006 \001(\005\022\034\n\024pub_" + "trigger_fd_index\030\007 \001(\005\022\036\n\026sub_trigger_fd" + "_indexes\030\010 \003(\005\022\027\n\017num_sub_updates\030\t \001(\005\022" + "\014\n\004type\030\n \001(\014\022\020\n\010vchan_id\030\013 \001(\005\022\033\n\023retir" + "ement_fd_index\030\016 \001(\005\022\035\n\025retirement_fd_in" + "dexes\030\017 \003(\005\"\314\001\n\027CreateSubscriberRequest\022" + "\024\n\014channel_name\030\001 \001(\t\022\025\n\rsubscriber_id\030\002" + " \001(\005\022\023\n\013is_reliable\030\003 \001(\010\022\021\n\tis_bridge\030\004" + " \001(\010\022\014\n\004type\030\005 \001(\014\022\033\n\023max_active_message" + "s\030\006 \001(\005\022\022\n\nfor_tunnel\030\t \001(\010\022\013\n\003mux\030\007 \001(\t" + "\022\020\n\010vchan_id\030\010 \001(\005\"\241\003\n\030CreateSubscriberR" + "esponse\022\r\n\005error\030\001 \001(\t\022\022\n\nchannel_id\030\002 \001" + "(\005\022\025\n\rsubscriber_id\030\003 \001(\005\022\024\n\014ccb_fd_inde" + "x\030\004 \001(\005\022\024\n\014bcb_fd_index\030\005 \001(\005\022\030\n\020trigger" + "_fd_index\030\006 \001(\005\022\025\n\rpoll_fd_index\030\007 \001(\005\022\021" + "\n\tslot_size\030\010 \001(\005\022\021\n\tnum_slots\030\t \001(\005\022\'\n\037" + "reliable_pub_trigger_fd_indexes\030\n \003(\005\022\027\n" + "\017num_pub_updates\030\013 \001(\005\022\014\n\004type\030\014 \001(\014\022\020\n\010" + "vchan_id\030\r \001(\005\022\035\n\025retirement_fd_indexes\030" + "\016 \003(\005\022\025\n\rchecksum_size\030\017 \001(\005\022\025\n\rmetadata" + "_size\030\020 \001(\005\022\031\n\021use_split_buffers\030\021 \001(\010\"*" + "\n\022GetTriggersRequest\022\024\n\014channel_name\030\001 \001" + "(\t\"\214\001\n\023GetTriggersResponse\022\r\n\005error\030\001 \001(" + "\t\022\'\n\037reliable_pub_trigger_fd_indexes\030\002 \003" + "(\005\022\036\n\026sub_trigger_fd_indexes\030\003 \003(\005\022\035\n\025re" + "tirement_fd_indexes\030\004 \003(\005\"D\n\026RemovePubli" + "sherRequest\022\024\n\014channel_name\030\001 \001(\t\022\024\n\014pub" + "lisher_id\030\002 \001(\005\"(\n\027RemovePublisherRespon" + "se\022\r\n\005error\030\001 \001(\t\"F\n\027RemoveSubscriberReq" + "uest\022\024\n\014channel_name\030\001 \001(\t\022\025\n\rsubscriber" + "_id\030\002 \001(\005\")\n\030RemoveSubscriberResponse\022\r\n" + "\005error\030\001 \001(\t\"-\n\025GetChannelInfoRequest\022\024\n" + "\014channel_name\030\001 \001(\t\"U\n\026GetChannelInfoRes" + "ponse\022\r\n\005error\030\001 \001(\t\022,\n\010channels\030\002 \003(\0132\032" + ".subspace.ChannelInfoProto\".\n\026GetChannel" + "StatsRequest\022\024\n\014channel_name\030\001 \001(\t\"W\n\027Ge" + "tChannelStatsResponse\022\r\n\005error\030\001 \001(\t\022-\n\010" + "channels\030\002 \003(\0132\033.subspace.ChannelStatsPr" + "oto\"\353\002\n\037ClientBufferHandleMetadataProto\022" + "\024\n\014channel_name\030\001 \001(\t\022\022\n\nsession_id\030\002 \001(" + "\004\022\024\n\014buffer_index\030\003 \001(\r\022\017\n\007slot_id\030\004 \001(\r" + "\022\021\n\tis_prefix\030\005 \001(\010\022\021\n\tfull_size\030\006 \001(\004\022\027" + "\n\017allocation_size\030\007 \001(\004\022\016\n\006handle\030\010 \001(\004\022" + "\023\n\013shadow_file\030\t \001(\t\022\023\n\013object_name\030\n \001(" + "\t\022\021\n\tallocator\030\013 \001(\t\022\017\n\007pool_id\030\014 \001(\t\022\025\n" + "\rcache_enabled\030\r \001(\010\022\021\n\talignment\030\016 \001(\r\022" + "0\n\022allocator_metadata\030\017 \001(\0132\024.google.pro" + "tobuf.Any\"Z\n\033RegisterClientBufferRequest" + "\022;\n\010metadata\030\001 \001(\0132).subspace.ClientBuff" + "erHandleMetadataProto\"_\n\035UnregisterClien" + "tBufferRequest\022\024\n\014channel_name\030\001 \001(\t\022\022\n\n" + "session_id\030\002 \001(\004\022\024\n\014buffer_index\030\003 \001(\r\"\377" + "\004\n\007Request\022%\n\004init\030\001 \001(\0132\025.subspace.Init" + "RequestH\000\022<\n\020create_publisher\030\002 \001(\0132 .su" + "bspace.CreatePublisherRequestH\000\022>\n\021creat" + "e_subscriber\030\003 \001(\0132!.subspace.CreateSubs" + "criberRequestH\000\0224\n\014get_triggers\030\004 \001(\0132\034." + "subspace.GetTriggersRequestH\000\022<\n\020remove_" + "publisher\030\005 \001(\0132 .subspace.RemovePublish" + "erRequestH\000\022>\n\021remove_subscriber\030\006 \001(\0132!" + ".subspace.RemoveSubscriberRequestH\000\022;\n\020g" + "et_channel_info\030\t \001(\0132\037.subspace.GetChan" + "nelInfoRequestH\000\022=\n\021get_channel_stats\030\n " + "\001(\0132 .subspace.GetChannelStatsRequestH\000\022" + "G\n\026register_client_buffer\030\013 \001(\0132%.subspa" + "ce.RegisterClientBufferRequestH\000\022K\n\030unre" + "gister_client_buffer\030\014 \001(\0132\'.subspace.Un" + "registerClientBufferRequestH\000B\t\n\007request" + "\"\363\003\n\010Response\022&\n\004init\030\001 \001(\0132\026.subspace.I" + "nitResponseH\000\022=\n\020create_publisher\030\002 \001(\0132" + "!.subspace.CreatePublisherResponseH\000\022\?\n\021" + "create_subscriber\030\003 \001(\0132\".subspace.Creat" + "eSubscriberResponseH\000\0225\n\014get_triggers\030\004 " + "\001(\0132\035.subspace.GetTriggersResponseH\000\022=\n\020" + "remove_publisher\030\005 \001(\0132!.subspace.Remove" + "PublisherResponseH\000\022\?\n\021remove_subscriber" + "\030\006 \001(\0132\".subspace.RemoveSubscriberRespon" + "seH\000\022<\n\020get_channel_info\030\t \001(\0132 .subspac" + "e.GetChannelInfoResponseH\000\022>\n\021get_channe" + "l_stats\030\n \001(\0132!.subspace.GetChannelStats" + "ResponseH\000B\n\n\010response\"\244\002\n\020ChannelInfoPr" + "oto\022\014\n\004name\030\001 \001(\t\022\021\n\tslot_size\030\002 \001(\005\022\021\n\t" + "num_slots\030\003 \001(\005\022\014\n\004type\030\004 \001(\014\022\020\n\010num_pub" + "s\030\005 \001(\005\022\020\n\010num_subs\030\006 \001(\005\022\027\n\017num_bridge_" + "pubs\030\007 \001(\005\022\027\n\017num_bridge_subs\030\010 \001(\005\022\023\n\013i" + "s_reliable\030\t \001(\010\022\027\n\017num_tunnel_pubs\030\r \001(" + "\005\022\027\n\017num_tunnel_subs\030\016 \001(\005\022\022\n\nis_virtual" + "\030\n \001(\010\022\020\n\010vchan_id\030\013 \001(\005\022\013\n\003mux\030\014 \001(\t\"S\n" + "\020ChannelDirectory\022\021\n\tserver_id\030\001 \001(\t\022,\n\010" + "channels\030\002 \003(\0132\032.subspace.ChannelInfoPro" + "to\"\201\002\n\021ChannelStatsProto\022\024\n\014channel_name" + "\030\001 \001(\t\022\023\n\013total_bytes\030\002 \001(\003\022\026\n\016total_mes" + "sages\030\003 \001(\003\022\021\n\tslot_size\030\004 \001(\005\022\021\n\tnum_sl" + "ots\030\005 \001(\005\022\020\n\010num_pubs\030\006 \001(\005\022\020\n\010num_subs\030" + "\007 \001(\005\022\030\n\020max_message_size\030\010 \001(\r\022\023\n\013total" + "_drops\030\t \001(\r\022\027\n\017num_bridge_pubs\030\n \001(\005\022\027\n" + "\017num_bridge_subs\030\013 \001(\005\"a\n\nStatistics\022\021\n\t" + "server_id\030\001 \001(\t\022\021\n\ttimestamp\030\002 \001(\003\022-\n\010ch" + "annels\030\003 \003(\0132\033.subspace.ChannelStatsProt" + "o\"/\n\016ChannelAddress\022\017\n\007address\030\001 \001(\014\022\014\n\004" + "port\030\002 \001(\005\"\222\002\n\nSubscribed\022\024\n\014channel_nam" + "e\030\001 \001(\t\022\021\n\tslot_size\030\002 \001(\005\022\021\n\tnum_slots\030" + "\003 \001(\005\022\020\n\010reliable\030\004 \001(\010\022\031\n\021notify_retire" + "ment\030\005 \001(\010\0223\n\021retirement_socket\030\006 \001(\0132\030." + "subspace.ChannelAddress\022\025\n\rchecksum_size" + "\030\007 \001(\005\022\025\n\rmetadata_size\030\010 \001(\005\022\025\n\rsplit_b" + "uffers\030\t \001(\010\022!\n\031split_buffers_over_bridg" + "e\030\n \001(\010\")\n\026RetirementNotification\022\017\n\007slo" + "t_id\030\001 \001(\005\"\257\003\n\tDiscovery\022\021\n\tserver_id\030\001 " + "\001(\t\022\014\n\004port\030\002 \001(\005\022*\n\005query\030\003 \001(\0132\031.subsp" + "ace.Discovery.QueryH\000\0222\n\tadvertise\030\004 \001(\013" + "2\035.subspace.Discovery.AdvertiseH\000\0222\n\tsub" + "scribe\030\005 \001(\0132\035.subspace.Discovery.Subscr" + "ibeH\000\032\035\n\005Query\022\024\n\014channel_name\030\001 \001(\t\032e\n\t" + "Advertise\022\024\n\014channel_name\030\001 \001(\t\022\020\n\010relia" + "ble\030\002 \001(\010\022\031\n\021notify_retirement\030\003 \001(\010\022\025\n\r" + "split_buffers\030\004 \001(\010\032_\n\tSubscribe\022\024\n\014chan" + "nel_name\030\001 \001(\t\022*\n\010receiver\030\002 \001(\0132\030.subsp" + "ace.ChannelAddress\022\020\n\010reliable\030\003 \001(\010B\006\n\004" + "data\"\020\n\016RpcOpenRequest\"\263\003\n\017RpcOpenRespon" + "se\022\022\n\nsession_id\030\001 \001(\005\0221\n\007methods\030\002 \003(\0132" + " .subspace.RpcOpenResponse.Method\022\021\n\tcli" + "ent_id\030\003 \001(\004\032R\n\016RequestChannel\022\014\n\004name\030\001" + " \001(\t\022\021\n\tslot_size\030\002 \001(\005\022\021\n\tnum_slots\030\003 \001" + "(\005\022\014\n\004type\030\004 \001(\t\032-\n\017ResponseChannel\022\014\n\004n" + "ame\030\001 \001(\t\022\014\n\004type\030\002 \001(\t\032\302\001\n\006Method\022\014\n\004na" + "me\030\001 \001(\t\022\n\n\002id\030\002 \001(\005\022A\n\017request_channel\030" + "\003 \001(\0132(.subspace.RpcOpenResponse.Request" + "Channel\022C\n\020response_channel\030\004 \001(\0132).subs" + "pace.RpcOpenResponse.ResponseChannel\022\026\n\016" + "cancel_channel\030\005 \001(\t\"%\n\017RpcCloseRequest\022" + "\022\n\nsession_id\030\001 \001(\005\"\022\n\020RpcCloseResponse\"" + "\232\001\n\020RpcServerRequest\022\021\n\tclient_id\030\001 \001(\004\022" + "\022\n\nrequest_id\030\002 \001(\005\022(\n\004open\030\003 \001(\0132\030.subs" + "pace.RpcOpenRequestH\000\022*\n\005close\030\004 \001(\0132\031.s" + "ubspace.RpcCloseRequestH\000B\t\n\007request\"\255\001\n" + "\021RpcServerResponse\022\021\n\tclient_id\030\001 \001(\004\022\022\n" + "\nrequest_id\030\002 \001(\005\022)\n\004open\030\003 \001(\0132\031.subspa" + "ce.RpcOpenResponseH\000\022+\n\005close\030\004 \001(\0132\032.su" + "bspace.RpcCloseResponseH\000\022\r\n\005error\030\005 \001(\t" + "B\n\n\010response\"\177\n\nRpcRequest\022\016\n\006method\030\001 \001" + "(\005\022&\n\010argument\030\002 \001(\0132\024.google.protobuf.A" + "ny\022\022\n\nsession_id\030\003 \001(\005\022\022\n\nrequest_id\030\004 \001" + "(\005\022\021\n\tclient_id\030\005 \001(\004\"\244\001\n\013RpcResponse\022\r\n" + "\005error\030\001 \001(\t\022$\n\006result\030\002 \001(\0132\024.google.pr" + "otobuf.Any\022\022\n\nsession_id\030\003 \001(\005\022\022\n\nreques" + "t_id\030\004 \001(\005\022\021\n\tclient_id\030\005 \001(\004\022\017\n\007is_last" + "\030\006 \001(\010\022\024\n\014is_cancelled\030\007 \001(\010\"M\n\020RpcCance" + "lRequest\022\022\n\nsession_id\030\001 \001(\005\022\022\n\nrequest_" + "id\030\002 \001(\005\022\021\n\tclient_id\030\003 \001(\004\"\032\n\nRawMessag" + "e\022\014\n\004data\030\001 \001(\014\"\r\n\013VoidMessage\"\330\005\n\013Shado" + "wEvent\022$\n\004init\030\001 \001(\0132\024.subspace.ShadowIn" + "itH\000\0227\n\016create_channel\030\002 \001(\0132\035.subspace." + "ShadowCreateChannelH\000\0227\n\016remove_channel\030" + "\003 \001(\0132\035.subspace.ShadowRemoveChannelH\000\0225" + "\n\radd_publisher\030\004 \001(\0132\034.subspace.ShadowA" + "ddPublisherH\000\022;\n\020remove_publisher\030\005 \001(\0132" + "\037.subspace.ShadowRemovePublisherH\000\0227\n\016ad" + "d_subscriber\030\006 \001(\0132\035.subspace.ShadowAddS" + "ubscriberH\000\022=\n\021remove_subscriber\030\007 \001(\0132 " + ".subspace.ShadowRemoveSubscriberH\000\022/\n\nst" + "ate_dump\030\010 \001(\0132\031.subspace.ShadowStateDum" + "pH\000\022/\n\nstate_done\030\t \001(\0132\031.subspace.Shado" + "wStateDoneH\000\022F\n\026register_client_buffer\030\n" + " \001(\0132$.subspace.ShadowRegisterClientBuff" + "erH\000\022J\n\030unregister_client_buffer\030\013 \001(\0132&" + ".subspace.ShadowUnregisterClientBufferH\000" + "\022F\n\026update_channel_options\030\014 \001(\0132$.subsp" + "ace.ShadowUpdateChannelOptionsH\000B\007\n\005even" + "t\" \n\nShadowInit\022\022\n\nsession_id\030\001 \001(\004\"\222\003\n\023" + "ShadowCreateChannel\022\024\n\014channel_name\030\001 \001(" + "\t\022\022\n\nchannel_id\030\002 \001(\005\022\021\n\tslot_size\030\003 \001(\005" + "\022\021\n\tnum_slots\030\004 \001(\005\022\014\n\004type\030\005 \001(\014\022\020\n\010is_" + "local\030\006 \001(\010\022\023\n\013is_reliable\030\007 \001(\010\022\025\n\ris_f" + "ixed_size\030\010 \001(\010\022\025\n\rchecksum_size\030\t \001(\005\022\025" + "\n\rmetadata_size\030\n \001(\005\022\013\n\003mux\030\013 \001(\t\022\020\n\010vc" + "han_id\030\014 \001(\005\022 \n\030has_split_buffer_options" + "\030\r \001(\010\022\031\n\021use_split_buffers\030\016 \001(\010\022\032\n\022has" + "_max_publishers\030\017 \001(\010\022\026\n\016max_publishers\030" + "\020 \001(\005\022!\n\031split_buffers_over_bridge\030\021 \001(\010" + "\"\?\n\023ShadowRemoveChannel\022\024\n\014channel_name\030" + "\001 \001(\t\022\022\n\nchannel_id\030\002 \001(\005\"\300\001\n\022ShadowAddP" + "ublisher\022\024\n\014channel_name\030\001 \001(\t\022\024\n\014publis" + "her_id\030\002 \001(\005\022\023\n\013is_reliable\030\003 \001(\010\022\020\n\010is_" + "local\030\004 \001(\010\022\021\n\tis_bridge\030\005 \001(\010\022\025\n\ris_fix" + "ed_size\030\006 \001(\010\022\031\n\021notify_retirement\030\007 \001(\010" + "\022\022\n\nfor_tunnel\030\010 \001(\010\"C\n\025ShadowRemovePubl" + "isher\022\024\n\014channel_name\030\001 \001(\t\022\024\n\014publisher" + "_id\030\002 \001(\005\"\233\001\n\023ShadowAddSubscriber\022\024\n\014cha" + "nnel_name\030\001 \001(\t\022\025\n\rsubscriber_id\030\002 \001(\005\022\023" + "\n\013is_reliable\030\003 \001(\010\022\021\n\tis_bridge\030\004 \001(\010\022\033" + "\n\023max_active_messages\030\005 \001(\005\022\022\n\nfor_tunne" + "l\030\006 \001(\010\"E\n\026ShadowRemoveSubscriber\022\024\n\014cha" + "nnel_name\030\001 \001(\t\022\025\n\rsubscriber_id\030\002 \001(\005\";" + "\n\017ShadowStateDump\022\022\n\nsession_id\030\001 \001(\004\022\024\n" + "\014num_channels\030\002 \001(\005\"\021\n\017ShadowStateDone\"Y" + "\n\032ShadowRegisterClientBuffer\022;\n\010metadata" + "\030\001 \001(\0132).subspace.ClientBufferHandleMeta" + "dataProto\"^\n\034ShadowUnregisterClientBuffe" + "r\022\024\n\014channel_name\030\001 \001(\t\022\022\n\nsession_id\030\002 " + "\001(\004\022\024\n\014buffer_index\030\003 \001(\r\"\306\001\n\032ShadowUpda" + "teChannelOptions\022\024\n\014channel_name\030\001 \001(\t\022 " + "\n\030has_split_buffer_options\030\002 \001(\010\022\031\n\021use_" + "split_buffers\030\003 \001(\010\022\032\n\022has_max_publisher" + "s\030\004 \001(\010\022\026\n\016max_publishers\030\005 \001(\005\022!\n\031split" + "_buffers_over_bridge\030\006 \001(\010b\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_subspace_2eproto_deps[1] = + { + &::descriptor_table_google_2fprotobuf_2fany_2eproto, +}; +static ::absl::once_flag descriptor_table_subspace_2eproto_once; +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_subspace_2eproto = { + false, + false, + 8954, + descriptor_table_protodef_subspace_2eproto, + "subspace.proto", + &descriptor_table_subspace_2eproto_once, + descriptor_table_subspace_2eproto_deps, + 1, + 59, + schemas, + file_default_instances, + TableStruct_subspace_2eproto::offsets, + file_level_enum_descriptors_subspace_2eproto, + file_level_service_descriptors_subspace_2eproto, +}; +namespace subspace { +// =================================================================== + +class InitRequest::_Internal { + public: +}; + +InitRequest::InitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.InitRequest) +} +inline PROTOBUF_NDEBUG_INLINE InitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::InitRequest& from_msg) + : client_name_(arena, from.client_name_), + _cached_size_{0} {} + +InitRequest::InitRequest( + ::google::protobuf::Arena* arena, + const InitRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + InitRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.InitRequest) +} +inline PROTOBUF_NDEBUG_INLINE InitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : client_name_(arena), + _cached_size_{0} {} + +inline void InitRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +InitRequest::~InitRequest() { + // @@protoc_insertion_point(destructor:subspace.InitRequest) + SharedDtor(*this); +} +inline void InitRequest::SharedDtor(MessageLite& self) { + InitRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.client_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* InitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) InitRequest(arena); +} +constexpr auto InitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(InitRequest), + alignof(InitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull InitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_InitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &InitRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &InitRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &InitRequest::ByteSizeLong, + &InitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(InitRequest, _impl_._cached_size_), + false, + }, + &InitRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* InitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 40, 2> InitRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::InitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string client_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(InitRequest, _impl_.client_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string client_name = 1; + {PROTOBUF_FIELD_OFFSET(InitRequest, _impl_.client_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\24\13\0\0\0\0\0\0" + "subspace.InitRequest" + "client_name" + }}, +}; + +PROTOBUF_NOINLINE void InitRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.InitRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.client_name_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* InitRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const InitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* InitRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const InitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.InitRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string client_name = 1; + if (!this_._internal_client_name().empty()) { + const std::string& _s = this_._internal_client_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.InitRequest.client_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.InitRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t InitRequest::ByteSizeLong(const MessageLite& base) { + const InitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t InitRequest::ByteSizeLong() const { + const InitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.InitRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string client_name = 1; + if (!this_._internal_client_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_client_name()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void InitRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.InitRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_client_name().empty()) { + _this->_internal_set_client_name(from._internal_client_name()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void InitRequest::CopyFrom(const InitRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.InitRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void InitRequest::InternalSwap(InitRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.client_name_, &other->_impl_.client_name_, arena); +} + +::google::protobuf::Metadata InitRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class InitResponse::_Internal { + public: +}; + +InitResponse::InitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.InitResponse) +} +InitResponse::InitResponse( + ::google::protobuf::Arena* arena, const InitResponse& from) + : InitResponse(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE InitResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void InitResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + 0, + offsetof(Impl_, group_id_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::group_id_)); +} +InitResponse::~InitResponse() { + // @@protoc_insertion_point(destructor:subspace.InitResponse) + SharedDtor(*this); +} +inline void InitResponse::SharedDtor(MessageLite& self) { + InitResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* InitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) InitResponse(arena); +} +constexpr auto InitResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(InitResponse), + alignof(InitResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull InitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_InitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &InitResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &InitResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &InitResponse::ByteSizeLong, + &InitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(InitResponse, _impl_._cached_size_), + false, + }, + &InitResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* InitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 0, 2> InitResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::InitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 group_id = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(InitResponse, _impl_.group_id_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.group_id_)}}, + // int32 scb_fd_index = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(InitResponse, _impl_.scb_fd_index_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.scb_fd_index_)}}, + // int64 session_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(InitResponse, _impl_.session_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.session_id_)}}, + // int32 user_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(InitResponse, _impl_.user_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.user_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 scb_fd_index = 1; + {PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.scb_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int64 session_id = 2; + {PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int32 user_id = 3; + {PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.user_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 group_id = 4; + {PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.group_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void InitResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.InitResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.group_id_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.group_id_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* InitResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const InitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* InitResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const InitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.InitResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 scb_fd_index = 1; + if (this_._internal_scb_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this_._internal_scb_fd_index(), target); + } + + // int64 session_id = 2; + if (this_._internal_session_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<2>( + stream, this_._internal_session_id(), target); + } + + // int32 user_id = 3; + if (this_._internal_user_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_user_id(), target); + } + + // int32 group_id = 4; + if (this_._internal_group_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_group_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.InitResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t InitResponse::ByteSizeLong(const MessageLite& base) { + const InitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t InitResponse::ByteSizeLong() const { + const InitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.InitResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // int64 session_id = 2; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_session_id()); + } + // int32 scb_fd_index = 1; + if (this_._internal_scb_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_scb_fd_index()); + } + // int32 user_id = 3; + if (this_._internal_user_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_user_id()); + } + // int32 group_id = 4; + if (this_._internal_group_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_group_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void InitResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.InitResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_scb_fd_index() != 0) { + _this->_impl_.scb_fd_index_ = from._impl_.scb_fd_index_; + } + if (from._internal_user_id() != 0) { + _this->_impl_.user_id_ = from._impl_.user_id_; + } + if (from._internal_group_id() != 0) { + _this->_impl_.group_id_ = from._impl_.group_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void InitResponse::CopyFrom(const InitResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.InitResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void InitResponse::InternalSwap(InitResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.group_id_) + + sizeof(InitResponse::_impl_.group_id_) + - PROTOBUF_FIELD_OFFSET(InitResponse, _impl_.session_id_)>( + reinterpret_cast(&_impl_.session_id_), + reinterpret_cast(&other->_impl_.session_id_)); +} + +::google::protobuf::Metadata InitResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class CreatePublisherRequest::_Internal { + public: +}; + +CreatePublisherRequest::CreatePublisherRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.CreatePublisherRequest) +} +inline PROTOBUF_NDEBUG_INLINE CreatePublisherRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::CreatePublisherRequest& from_msg) + : channel_name_(arena, from.channel_name_), + type_(arena, from.type_), + mux_(arena, from.mux_), + _cached_size_{0} {} + +CreatePublisherRequest::CreatePublisherRequest( + ::google::protobuf::Arena* arena, + const CreatePublisherRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + CreatePublisherRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, num_slots_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, num_slots_), + offsetof(Impl_, max_publishers_) - + offsetof(Impl_, num_slots_) + + sizeof(Impl_::max_publishers_)); + + // @@protoc_insertion_point(copy_constructor:subspace.CreatePublisherRequest) +} +inline PROTOBUF_NDEBUG_INLINE CreatePublisherRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + type_(arena), + mux_(arena), + _cached_size_{0} {} + +inline void CreatePublisherRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, num_slots_), + 0, + offsetof(Impl_, max_publishers_) - + offsetof(Impl_, num_slots_) + + sizeof(Impl_::max_publishers_)); +} +CreatePublisherRequest::~CreatePublisherRequest() { + // @@protoc_insertion_point(destructor:subspace.CreatePublisherRequest) + SharedDtor(*this); +} +inline void CreatePublisherRequest::SharedDtor(MessageLite& self) { + CreatePublisherRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.mux_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* CreatePublisherRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CreatePublisherRequest(arena); +} +constexpr auto CreatePublisherRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(CreatePublisherRequest), + alignof(CreatePublisherRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull CreatePublisherRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_CreatePublisherRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CreatePublisherRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CreatePublisherRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &CreatePublisherRequest::ByteSizeLong, + &CreatePublisherRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_._cached_size_), + false, + }, + &CreatePublisherRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* CreatePublisherRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<5, 18, 0, 71, 2> CreatePublisherRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 18, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294705152, // skipmap + offsetof(decltype(_table_), field_entries), + 18, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::CreatePublisherRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.channel_name_)}}, + // int32 num_slots = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherRequest, _impl_.num_slots_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.num_slots_)}}, + // int32 slot_size = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherRequest, _impl_.slot_size_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.slot_size_)}}, + // bool is_local = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_local_)}}, + // bool is_reliable = 5; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_reliable_)}}, + // bool is_bridge = 6; + {::_pbi::TcParser::SingularVarintNoZag1(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_bridge_)}}, + // bytes type = 7; + {::_pbi::TcParser::FastBS1, + {58, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.type_)}}, + // bool is_fixed_size = 8; + {::_pbi::TcParser::SingularVarintNoZag1(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_fixed_size_)}}, + // string mux = 9; + {::_pbi::TcParser::FastUS1, + {74, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.mux_)}}, + // int32 vchan_id = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherRequest, _impl_.vchan_id_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.vchan_id_)}}, + // bool notify_retirement = 11; + {::_pbi::TcParser::SingularVarintNoZag1(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.notify_retirement_)}}, + // int32 checksum_size = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherRequest, _impl_.checksum_size_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.checksum_size_)}}, + // int32 metadata_size = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherRequest, _impl_.metadata_size_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.metadata_size_)}}, + // int32 publisher_id = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherRequest, _impl_.publisher_id_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.publisher_id_)}}, + // bool for_tunnel = 15; + {::_pbi::TcParser::SingularVarintNoZag1(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.for_tunnel_)}}, + // bool use_split_buffers = 16; + {::_pbi::TcParser::FastV8S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.use_split_buffers_)}}, + // int32 max_publishers = 17; + {::_pbi::TcParser::FastV32S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.max_publishers_)}}, + // bool split_buffers_over_bridge = 18; + {::_pbi::TcParser::FastV8S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.split_buffers_over_bridge_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 num_slots = 2; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.num_slots_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 slot_size = 3; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.slot_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool is_local = 4; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_local_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_reliable = 5; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_bridge = 6; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bytes type = 7; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bool is_fixed_size = 8; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.is_fixed_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // string mux = 9; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.mux_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 vchan_id = 10; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.vchan_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool notify_retirement = 11; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.notify_retirement_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 checksum_size = 12; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.checksum_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 metadata_size = 13; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.metadata_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 publisher_id = 14; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.publisher_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool for_tunnel = 15; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.for_tunnel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool use_split_buffers = 16; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.use_split_buffers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 max_publishers = 17; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.max_publishers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool split_buffers_over_bridge = 18; + {PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.split_buffers_over_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\37\14\0\0\0\0\0\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.CreatePublisherRequest" + "channel_name" + "mux" + }}, +}; + +PROTOBUF_NOINLINE void CreatePublisherRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.CreatePublisherRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + _impl_.mux_.ClearToEmpty(); + ::memset(&_impl_.num_slots_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.max_publishers_) - + reinterpret_cast(&_impl_.num_slots_)) + sizeof(_impl_.max_publishers_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CreatePublisherRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CreatePublisherRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CreatePublisherRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CreatePublisherRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.CreatePublisherRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.CreatePublisherRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 num_slots = 2; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_num_slots(), target); + } + + // int32 slot_size = 3; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_slot_size(), target); + } + + // bool is_local = 4; + if (this_._internal_is_local() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_is_local(), target); + } + + // bool is_reliable = 5; + if (this_._internal_is_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_is_reliable(), target); + } + + // bool is_bridge = 6; + if (this_._internal_is_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_is_bridge(), target); + } + + // bytes type = 7; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + target = stream->WriteBytesMaybeAliased(7, _s, target); + } + + // bool is_fixed_size = 8; + if (this_._internal_is_fixed_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 8, this_._internal_is_fixed_size(), target); + } + + // string mux = 9; + if (!this_._internal_mux().empty()) { + const std::string& _s = this_._internal_mux(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.CreatePublisherRequest.mux"); + target = stream->WriteStringMaybeAliased(9, _s, target); + } + + // int32 vchan_id = 10; + if (this_._internal_vchan_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<10>( + stream, this_._internal_vchan_id(), target); + } + + // bool notify_retirement = 11; + if (this_._internal_notify_retirement() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 11, this_._internal_notify_retirement(), target); + } + + // int32 checksum_size = 12; + if (this_._internal_checksum_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<12>( + stream, this_._internal_checksum_size(), target); + } + + // int32 metadata_size = 13; + if (this_._internal_metadata_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this_._internal_metadata_size(), target); + } + + // int32 publisher_id = 14; + if (this_._internal_publisher_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this_._internal_publisher_id(), target); + } + + // bool for_tunnel = 15; + if (this_._internal_for_tunnel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 15, this_._internal_for_tunnel(), target); + } + + // bool use_split_buffers = 16; + if (this_._internal_use_split_buffers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 16, this_._internal_use_split_buffers(), target); + } + + // int32 max_publishers = 17; + if (this_._internal_max_publishers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 17, this_._internal_max_publishers(), target); + } + + // bool split_buffers_over_bridge = 18; + if (this_._internal_split_buffers_over_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 18, this_._internal_split_buffers_over_bridge(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.CreatePublisherRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CreatePublisherRequest::ByteSizeLong(const MessageLite& base) { + const CreatePublisherRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CreatePublisherRequest::ByteSizeLong() const { + const CreatePublisherRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.CreatePublisherRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // bytes type = 7; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_type()); + } + // string mux = 9; + if (!this_._internal_mux().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_mux()); + } + // int32 num_slots = 2; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + // int32 slot_size = 3; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // bool is_local = 4; + if (this_._internal_is_local() != 0) { + total_size += 2; + } + // bool is_reliable = 5; + if (this_._internal_is_reliable() != 0) { + total_size += 2; + } + // bool is_bridge = 6; + if (this_._internal_is_bridge() != 0) { + total_size += 2; + } + // bool is_fixed_size = 8; + if (this_._internal_is_fixed_size() != 0) { + total_size += 2; + } + // int32 vchan_id = 10; + if (this_._internal_vchan_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_vchan_id()); + } + // int32 checksum_size = 12; + if (this_._internal_checksum_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_checksum_size()); + } + // int32 metadata_size = 13; + if (this_._internal_metadata_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_metadata_size()); + } + // int32 publisher_id = 14; + if (this_._internal_publisher_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_publisher_id()); + } + // bool for_tunnel = 15; + if (this_._internal_for_tunnel() != 0) { + total_size += 2; + } + // bool notify_retirement = 11; + if (this_._internal_notify_retirement() != 0) { + total_size += 2; + } + // bool use_split_buffers = 16; + if (this_._internal_use_split_buffers() != 0) { + total_size += 3; + } + // bool split_buffers_over_bridge = 18; + if (this_._internal_split_buffers_over_bridge() != 0) { + total_size += 3; + } + // int32 max_publishers = 17; + if (this_._internal_max_publishers() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int32Size( + this_._internal_max_publishers()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void CreatePublisherRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.CreatePublisherRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (!from._internal_mux().empty()) { + _this->_internal_set_mux(from._internal_mux()); + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_is_local() != 0) { + _this->_impl_.is_local_ = from._impl_.is_local_; + } + if (from._internal_is_reliable() != 0) { + _this->_impl_.is_reliable_ = from._impl_.is_reliable_; + } + if (from._internal_is_bridge() != 0) { + _this->_impl_.is_bridge_ = from._impl_.is_bridge_; + } + if (from._internal_is_fixed_size() != 0) { + _this->_impl_.is_fixed_size_ = from._impl_.is_fixed_size_; + } + if (from._internal_vchan_id() != 0) { + _this->_impl_.vchan_id_ = from._impl_.vchan_id_; + } + if (from._internal_checksum_size() != 0) { + _this->_impl_.checksum_size_ = from._impl_.checksum_size_; + } + if (from._internal_metadata_size() != 0) { + _this->_impl_.metadata_size_ = from._impl_.metadata_size_; + } + if (from._internal_publisher_id() != 0) { + _this->_impl_.publisher_id_ = from._impl_.publisher_id_; + } + if (from._internal_for_tunnel() != 0) { + _this->_impl_.for_tunnel_ = from._impl_.for_tunnel_; + } + if (from._internal_notify_retirement() != 0) { + _this->_impl_.notify_retirement_ = from._impl_.notify_retirement_; + } + if (from._internal_use_split_buffers() != 0) { + _this->_impl_.use_split_buffers_ = from._impl_.use_split_buffers_; + } + if (from._internal_split_buffers_over_bridge() != 0) { + _this->_impl_.split_buffers_over_bridge_ = from._impl_.split_buffers_over_bridge_; + } + if (from._internal_max_publishers() != 0) { + _this->_impl_.max_publishers_ = from._impl_.max_publishers_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void CreatePublisherRequest::CopyFrom(const CreatePublisherRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.CreatePublisherRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CreatePublisherRequest::InternalSwap(CreatePublisherRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.mux_, &other->_impl_.mux_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.max_publishers_) + + sizeof(CreatePublisherRequest::_impl_.max_publishers_) + - PROTOBUF_FIELD_OFFSET(CreatePublisherRequest, _impl_.num_slots_)>( + reinterpret_cast(&_impl_.num_slots_), + reinterpret_cast(&other->_impl_.num_slots_)); +} + +::google::protobuf::Metadata CreatePublisherRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class CreatePublisherResponse::_Internal { + public: +}; + +CreatePublisherResponse::CreatePublisherResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.CreatePublisherResponse) +} +inline PROTOBUF_NDEBUG_INLINE CreatePublisherResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::CreatePublisherResponse& from_msg) + : sub_trigger_fd_indexes_{visibility, arena, from.sub_trigger_fd_indexes_}, + _sub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{visibility, arena, from.retirement_fd_indexes_}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_(arena, from.error_), + type_(arena, from.type_), + _cached_size_{0} {} + +CreatePublisherResponse::CreatePublisherResponse( + ::google::protobuf::Arena* arena, + const CreatePublisherResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + CreatePublisherResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, channel_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, channel_id_), + offsetof(Impl_, retirement_fd_index_) - + offsetof(Impl_, channel_id_) + + sizeof(Impl_::retirement_fd_index_)); + + // @@protoc_insertion_point(copy_constructor:subspace.CreatePublisherResponse) +} +inline PROTOBUF_NDEBUG_INLINE CreatePublisherResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : sub_trigger_fd_indexes_{visibility, arena}, + _sub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{visibility, arena}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_(arena), + type_(arena), + _cached_size_{0} {} + +inline void CreatePublisherResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, channel_id_), + 0, + offsetof(Impl_, retirement_fd_index_) - + offsetof(Impl_, channel_id_) + + sizeof(Impl_::retirement_fd_index_)); +} +CreatePublisherResponse::~CreatePublisherResponse() { + // @@protoc_insertion_point(destructor:subspace.CreatePublisherResponse) + SharedDtor(*this); +} +inline void CreatePublisherResponse::SharedDtor(MessageLite& self) { + CreatePublisherResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* CreatePublisherResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CreatePublisherResponse(arena); +} +constexpr auto CreatePublisherResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.sub_trigger_fd_indexes_) + + decltype(CreatePublisherResponse::_impl_.sub_trigger_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.retirement_fd_indexes_) + + decltype(CreatePublisherResponse::_impl_.retirement_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(CreatePublisherResponse), alignof(CreatePublisherResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&CreatePublisherResponse::PlacementNew_, + sizeof(CreatePublisherResponse), + alignof(CreatePublisherResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull CreatePublisherResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_CreatePublisherResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CreatePublisherResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CreatePublisherResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &CreatePublisherResponse::ByteSizeLong, + &CreatePublisherResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_._cached_size_), + false, + }, + &CreatePublisherResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* CreatePublisherResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 13, 0, 54, 2> CreatePublisherResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 15, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294940672, // skipmap + offsetof(decltype(_table_), field_entries), + 13, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::CreatePublisherResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.error_)}}, + // int32 channel_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.channel_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.channel_id_)}}, + // int32 publisher_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.publisher_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.publisher_id_)}}, + // int32 ccb_fd_index = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.ccb_fd_index_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.ccb_fd_index_)}}, + // int32 bcb_fd_index = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.bcb_fd_index_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.bcb_fd_index_)}}, + // int32 pub_poll_fd_index = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.pub_poll_fd_index_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.pub_poll_fd_index_)}}, + // int32 pub_trigger_fd_index = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.pub_trigger_fd_index_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.pub_trigger_fd_index_)}}, + // repeated int32 sub_trigger_fd_indexes = 8; + {::_pbi::TcParser::FastV32P1, + {66, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.sub_trigger_fd_indexes_)}}, + // int32 num_sub_updates = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.num_sub_updates_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.num_sub_updates_)}}, + // bytes type = 10; + {::_pbi::TcParser::FastBS1, + {82, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.type_)}}, + // int32 vchan_id = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.vchan_id_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.vchan_id_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + // int32 retirement_fd_index = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreatePublisherResponse, _impl_.retirement_fd_index_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.retirement_fd_index_)}}, + // repeated int32 retirement_fd_indexes = 15; + {::_pbi::TcParser::FastV32P1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.retirement_fd_indexes_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 channel_id = 2; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.channel_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 publisher_id = 3; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.publisher_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 ccb_fd_index = 4; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.ccb_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 bcb_fd_index = 5; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.bcb_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 pub_poll_fd_index = 6; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.pub_poll_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 pub_trigger_fd_index = 7; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.pub_trigger_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated int32 sub_trigger_fd_indexes = 8; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.sub_trigger_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + // int32 num_sub_updates = 9; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.num_sub_updates_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes type = 10; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // int32 vchan_id = 11; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.vchan_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 retirement_fd_index = 14; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.retirement_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated int32 retirement_fd_indexes = 15; + {PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.retirement_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + }}, + // no aux_entries + {{ + "\40\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.CreatePublisherResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void CreatePublisherResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.CreatePublisherResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.sub_trigger_fd_indexes_.Clear(); + _impl_.retirement_fd_indexes_.Clear(); + _impl_.error_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + ::memset(&_impl_.channel_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.retirement_fd_index_) - + reinterpret_cast(&_impl_.channel_id_)) + sizeof(_impl_.retirement_fd_index_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CreatePublisherResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CreatePublisherResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CreatePublisherResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CreatePublisherResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.CreatePublisherResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.CreatePublisherResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_channel_id(), target); + } + + // int32 publisher_id = 3; + if (this_._internal_publisher_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_publisher_id(), target); + } + + // int32 ccb_fd_index = 4; + if (this_._internal_ccb_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_ccb_fd_index(), target); + } + + // int32 bcb_fd_index = 5; + if (this_._internal_bcb_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this_._internal_bcb_fd_index(), target); + } + + // int32 pub_poll_fd_index = 6; + if (this_._internal_pub_poll_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this_._internal_pub_poll_fd_index(), target); + } + + // int32 pub_trigger_fd_index = 7; + if (this_._internal_pub_trigger_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this_._internal_pub_trigger_fd_index(), target); + } + + // repeated int32 sub_trigger_fd_indexes = 8; + { + int byte_size = this_._impl_._sub_trigger_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 8, this_._internal_sub_trigger_fd_indexes(), byte_size, target); + } + } + + // int32 num_sub_updates = 9; + if (this_._internal_num_sub_updates() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<9>( + stream, this_._internal_num_sub_updates(), target); + } + + // bytes type = 10; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + target = stream->WriteBytesMaybeAliased(10, _s, target); + } + + // int32 vchan_id = 11; + if (this_._internal_vchan_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<11>( + stream, this_._internal_vchan_id(), target); + } + + // int32 retirement_fd_index = 14; + if (this_._internal_retirement_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this_._internal_retirement_fd_index(), target); + } + + // repeated int32 retirement_fd_indexes = 15; + { + int byte_size = this_._impl_._retirement_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 15, this_._internal_retirement_fd_indexes(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.CreatePublisherResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CreatePublisherResponse::ByteSizeLong(const MessageLite& base) { + const CreatePublisherResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CreatePublisherResponse::ByteSizeLong() const { + const CreatePublisherResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.CreatePublisherResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated int32 sub_trigger_fd_indexes = 8; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_sub_trigger_fd_indexes(), 1, + this_._impl_._sub_trigger_fd_indexes_cached_byte_size_); + } + // repeated int32 retirement_fd_indexes = 15; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_retirement_fd_indexes(), 1, + this_._impl_._retirement_fd_indexes_cached_byte_size_); + } + } + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + // bytes type = 10; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_type()); + } + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_channel_id()); + } + // int32 publisher_id = 3; + if (this_._internal_publisher_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_publisher_id()); + } + // int32 ccb_fd_index = 4; + if (this_._internal_ccb_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_ccb_fd_index()); + } + // int32 bcb_fd_index = 5; + if (this_._internal_bcb_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_bcb_fd_index()); + } + // int32 pub_poll_fd_index = 6; + if (this_._internal_pub_poll_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_pub_poll_fd_index()); + } + // int32 pub_trigger_fd_index = 7; + if (this_._internal_pub_trigger_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_pub_trigger_fd_index()); + } + // int32 num_sub_updates = 9; + if (this_._internal_num_sub_updates() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_sub_updates()); + } + // int32 vchan_id = 11; + if (this_._internal_vchan_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_vchan_id()); + } + // int32 retirement_fd_index = 14; + if (this_._internal_retirement_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_retirement_fd_index()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void CreatePublisherResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.CreatePublisherResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_sub_trigger_fd_indexes()->MergeFrom(from._internal_sub_trigger_fd_indexes()); + _this->_internal_mutable_retirement_fd_indexes()->MergeFrom(from._internal_retirement_fd_indexes()); + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (from._internal_channel_id() != 0) { + _this->_impl_.channel_id_ = from._impl_.channel_id_; + } + if (from._internal_publisher_id() != 0) { + _this->_impl_.publisher_id_ = from._impl_.publisher_id_; + } + if (from._internal_ccb_fd_index() != 0) { + _this->_impl_.ccb_fd_index_ = from._impl_.ccb_fd_index_; + } + if (from._internal_bcb_fd_index() != 0) { + _this->_impl_.bcb_fd_index_ = from._impl_.bcb_fd_index_; + } + if (from._internal_pub_poll_fd_index() != 0) { + _this->_impl_.pub_poll_fd_index_ = from._impl_.pub_poll_fd_index_; + } + if (from._internal_pub_trigger_fd_index() != 0) { + _this->_impl_.pub_trigger_fd_index_ = from._impl_.pub_trigger_fd_index_; + } + if (from._internal_num_sub_updates() != 0) { + _this->_impl_.num_sub_updates_ = from._impl_.num_sub_updates_; + } + if (from._internal_vchan_id() != 0) { + _this->_impl_.vchan_id_ = from._impl_.vchan_id_; + } + if (from._internal_retirement_fd_index() != 0) { + _this->_impl_.retirement_fd_index_ = from._impl_.retirement_fd_index_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void CreatePublisherResponse::CopyFrom(const CreatePublisherResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.CreatePublisherResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CreatePublisherResponse::InternalSwap(CreatePublisherResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.sub_trigger_fd_indexes_.InternalSwap(&other->_impl_.sub_trigger_fd_indexes_); + _impl_.retirement_fd_indexes_.InternalSwap(&other->_impl_.retirement_fd_indexes_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.retirement_fd_index_) + + sizeof(CreatePublisherResponse::_impl_.retirement_fd_index_) + - PROTOBUF_FIELD_OFFSET(CreatePublisherResponse, _impl_.channel_id_)>( + reinterpret_cast(&_impl_.channel_id_), + reinterpret_cast(&other->_impl_.channel_id_)); +} + +::google::protobuf::Metadata CreatePublisherResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class CreateSubscriberRequest::_Internal { + public: +}; + +CreateSubscriberRequest::CreateSubscriberRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.CreateSubscriberRequest) +} +inline PROTOBUF_NDEBUG_INLINE CreateSubscriberRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::CreateSubscriberRequest& from_msg) + : channel_name_(arena, from.channel_name_), + type_(arena, from.type_), + mux_(arena, from.mux_), + _cached_size_{0} {} + +CreateSubscriberRequest::CreateSubscriberRequest( + ::google::protobuf::Arena* arena, + const CreateSubscriberRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + CreateSubscriberRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, subscriber_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, subscriber_id_), + offsetof(Impl_, vchan_id_) - + offsetof(Impl_, subscriber_id_) + + sizeof(Impl_::vchan_id_)); + + // @@protoc_insertion_point(copy_constructor:subspace.CreateSubscriberRequest) +} +inline PROTOBUF_NDEBUG_INLINE CreateSubscriberRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + type_(arena), + mux_(arena), + _cached_size_{0} {} + +inline void CreateSubscriberRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, subscriber_id_), + 0, + offsetof(Impl_, vchan_id_) - + offsetof(Impl_, subscriber_id_) + + sizeof(Impl_::vchan_id_)); +} +CreateSubscriberRequest::~CreateSubscriberRequest() { + // @@protoc_insertion_point(destructor:subspace.CreateSubscriberRequest) + SharedDtor(*this); +} +inline void CreateSubscriberRequest::SharedDtor(MessageLite& self) { + CreateSubscriberRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.mux_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* CreateSubscriberRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CreateSubscriberRequest(arena); +} +constexpr auto CreateSubscriberRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(CreateSubscriberRequest), + alignof(CreateSubscriberRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull CreateSubscriberRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_CreateSubscriberRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CreateSubscriberRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CreateSubscriberRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &CreateSubscriberRequest::ByteSizeLong, + &CreateSubscriberRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_._cached_size_), + false, + }, + &CreateSubscriberRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* CreateSubscriberRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 9, 0, 64, 2> CreateSubscriberRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 9, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966784, // skipmap + offsetof(decltype(_table_), field_entries), + 9, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::CreateSubscriberRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.channel_name_)}}, + // int32 subscriber_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberRequest, _impl_.subscriber_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.subscriber_id_)}}, + // bool is_reliable = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.is_reliable_)}}, + // bool is_bridge = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.is_bridge_)}}, + // bytes type = 5; + {::_pbi::TcParser::FastBS1, + {42, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.type_)}}, + // int32 max_active_messages = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberRequest, _impl_.max_active_messages_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.max_active_messages_)}}, + // string mux = 7; + {::_pbi::TcParser::FastUS1, + {58, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.mux_)}}, + // int32 vchan_id = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberRequest, _impl_.vchan_id_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.vchan_id_)}}, + // bool for_tunnel = 9; + {::_pbi::TcParser::SingularVarintNoZag1(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.for_tunnel_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 subscriber_id = 2; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.subscriber_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool is_reliable = 3; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.is_reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_bridge = 4; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.is_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bytes type = 5; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // int32 max_active_messages = 6; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.max_active_messages_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // string mux = 7; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.mux_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 vchan_id = 8; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.vchan_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool for_tunnel = 9; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.for_tunnel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\40\14\0\0\0\0\0\3\0\0\0\0\0\0\0\0" + "subspace.CreateSubscriberRequest" + "channel_name" + "mux" + }}, +}; + +PROTOBUF_NOINLINE void CreateSubscriberRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.CreateSubscriberRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + _impl_.mux_.ClearToEmpty(); + ::memset(&_impl_.subscriber_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.vchan_id_) - + reinterpret_cast(&_impl_.subscriber_id_)) + sizeof(_impl_.vchan_id_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CreateSubscriberRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CreateSubscriberRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CreateSubscriberRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CreateSubscriberRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.CreateSubscriberRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.CreateSubscriberRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_subscriber_id(), target); + } + + // bool is_reliable = 3; + if (this_._internal_is_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_is_reliable(), target); + } + + // bool is_bridge = 4; + if (this_._internal_is_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_is_bridge(), target); + } + + // bytes type = 5; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + target = stream->WriteBytesMaybeAliased(5, _s, target); + } + + // int32 max_active_messages = 6; + if (this_._internal_max_active_messages() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this_._internal_max_active_messages(), target); + } + + // string mux = 7; + if (!this_._internal_mux().empty()) { + const std::string& _s = this_._internal_mux(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.CreateSubscriberRequest.mux"); + target = stream->WriteStringMaybeAliased(7, _s, target); + } + + // int32 vchan_id = 8; + if (this_._internal_vchan_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<8>( + stream, this_._internal_vchan_id(), target); + } + + // bool for_tunnel = 9; + if (this_._internal_for_tunnel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 9, this_._internal_for_tunnel(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.CreateSubscriberRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CreateSubscriberRequest::ByteSizeLong(const MessageLite& base) { + const CreateSubscriberRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CreateSubscriberRequest::ByteSizeLong() const { + const CreateSubscriberRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.CreateSubscriberRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // bytes type = 5; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_type()); + } + // string mux = 7; + if (!this_._internal_mux().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_mux()); + } + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_subscriber_id()); + } + // bool is_reliable = 3; + if (this_._internal_is_reliable() != 0) { + total_size += 2; + } + // bool is_bridge = 4; + if (this_._internal_is_bridge() != 0) { + total_size += 2; + } + // bool for_tunnel = 9; + if (this_._internal_for_tunnel() != 0) { + total_size += 2; + } + // int32 max_active_messages = 6; + if (this_._internal_max_active_messages() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_max_active_messages()); + } + // int32 vchan_id = 8; + if (this_._internal_vchan_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_vchan_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void CreateSubscriberRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.CreateSubscriberRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (!from._internal_mux().empty()) { + _this->_internal_set_mux(from._internal_mux()); + } + if (from._internal_subscriber_id() != 0) { + _this->_impl_.subscriber_id_ = from._impl_.subscriber_id_; + } + if (from._internal_is_reliable() != 0) { + _this->_impl_.is_reliable_ = from._impl_.is_reliable_; + } + if (from._internal_is_bridge() != 0) { + _this->_impl_.is_bridge_ = from._impl_.is_bridge_; + } + if (from._internal_for_tunnel() != 0) { + _this->_impl_.for_tunnel_ = from._impl_.for_tunnel_; + } + if (from._internal_max_active_messages() != 0) { + _this->_impl_.max_active_messages_ = from._impl_.max_active_messages_; + } + if (from._internal_vchan_id() != 0) { + _this->_impl_.vchan_id_ = from._impl_.vchan_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void CreateSubscriberRequest::CopyFrom(const CreateSubscriberRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.CreateSubscriberRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CreateSubscriberRequest::InternalSwap(CreateSubscriberRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.mux_, &other->_impl_.mux_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.vchan_id_) + + sizeof(CreateSubscriberRequest::_impl_.vchan_id_) + - PROTOBUF_FIELD_OFFSET(CreateSubscriberRequest, _impl_.subscriber_id_)>( + reinterpret_cast(&_impl_.subscriber_id_), + reinterpret_cast(&other->_impl_.subscriber_id_)); +} + +::google::protobuf::Metadata CreateSubscriberRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class CreateSubscriberResponse::_Internal { + public: +}; + +CreateSubscriberResponse::CreateSubscriberResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.CreateSubscriberResponse) +} +inline PROTOBUF_NDEBUG_INLINE CreateSubscriberResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::CreateSubscriberResponse& from_msg) + : reliable_pub_trigger_fd_indexes_{visibility, arena, from.reliable_pub_trigger_fd_indexes_}, + _reliable_pub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{visibility, arena, from.retirement_fd_indexes_}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_(arena, from.error_), + type_(arena, from.type_), + _cached_size_{0} {} + +CreateSubscriberResponse::CreateSubscriberResponse( + ::google::protobuf::Arena* arena, + const CreateSubscriberResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + CreateSubscriberResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, channel_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, channel_id_), + offsetof(Impl_, use_split_buffers_) - + offsetof(Impl_, channel_id_) + + sizeof(Impl_::use_split_buffers_)); + + // @@protoc_insertion_point(copy_constructor:subspace.CreateSubscriberResponse) +} +inline PROTOBUF_NDEBUG_INLINE CreateSubscriberResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : reliable_pub_trigger_fd_indexes_{visibility, arena}, + _reliable_pub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{visibility, arena}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_(arena), + type_(arena), + _cached_size_{0} {} + +inline void CreateSubscriberResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, channel_id_), + 0, + offsetof(Impl_, use_split_buffers_) - + offsetof(Impl_, channel_id_) + + sizeof(Impl_::use_split_buffers_)); +} +CreateSubscriberResponse::~CreateSubscriberResponse() { + // @@protoc_insertion_point(destructor:subspace.CreateSubscriberResponse) + SharedDtor(*this); +} +inline void CreateSubscriberResponse::SharedDtor(MessageLite& self) { + CreateSubscriberResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* CreateSubscriberResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CreateSubscriberResponse(arena); +} +constexpr auto CreateSubscriberResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.reliable_pub_trigger_fd_indexes_) + + decltype(CreateSubscriberResponse::_impl_.reliable_pub_trigger_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.retirement_fd_indexes_) + + decltype(CreateSubscriberResponse::_impl_.retirement_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(CreateSubscriberResponse), alignof(CreateSubscriberResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&CreateSubscriberResponse::PlacementNew_, + sizeof(CreateSubscriberResponse), + alignof(CreateSubscriberResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull CreateSubscriberResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_CreateSubscriberResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CreateSubscriberResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CreateSubscriberResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &CreateSubscriberResponse::ByteSizeLong, + &CreateSubscriberResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_._cached_size_), + false, + }, + &CreateSubscriberResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* CreateSubscriberResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<5, 17, 0, 63, 2> CreateSubscriberResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 17, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294836224, // skipmap + offsetof(decltype(_table_), field_entries), + 17, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::CreateSubscriberResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.error_)}}, + // int32 channel_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.channel_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.channel_id_)}}, + // int32 subscriber_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.subscriber_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.subscriber_id_)}}, + // int32 ccb_fd_index = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.ccb_fd_index_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.ccb_fd_index_)}}, + // int32 bcb_fd_index = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.bcb_fd_index_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.bcb_fd_index_)}}, + // int32 trigger_fd_index = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.trigger_fd_index_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.trigger_fd_index_)}}, + // int32 poll_fd_index = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.poll_fd_index_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.poll_fd_index_)}}, + // int32 slot_size = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.slot_size_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.slot_size_)}}, + // int32 num_slots = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.num_slots_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.num_slots_)}}, + // repeated int32 reliable_pub_trigger_fd_indexes = 10; + {::_pbi::TcParser::FastV32P1, + {82, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.reliable_pub_trigger_fd_indexes_)}}, + // int32 num_pub_updates = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.num_pub_updates_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.num_pub_updates_)}}, + // bytes type = 12; + {::_pbi::TcParser::FastBS1, + {98, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.type_)}}, + // int32 vchan_id = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.vchan_id_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.vchan_id_)}}, + // repeated int32 retirement_fd_indexes = 14; + {::_pbi::TcParser::FastV32P1, + {114, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.retirement_fd_indexes_)}}, + // int32 checksum_size = 15; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(CreateSubscriberResponse, _impl_.checksum_size_), 63>(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.checksum_size_)}}, + // int32 metadata_size = 16; + {::_pbi::TcParser::FastV32S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.metadata_size_)}}, + // bool use_split_buffers = 17; + {::_pbi::TcParser::FastV8S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.use_split_buffers_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 channel_id = 2; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.channel_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 subscriber_id = 3; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.subscriber_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 ccb_fd_index = 4; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.ccb_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 bcb_fd_index = 5; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.bcb_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 trigger_fd_index = 6; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.trigger_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 poll_fd_index = 7; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.poll_fd_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 slot_size = 8; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.slot_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_slots = 9; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.num_slots_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated int32 reliable_pub_trigger_fd_indexes = 10; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.reliable_pub_trigger_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + // int32 num_pub_updates = 11; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.num_pub_updates_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes type = 12; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // int32 vchan_id = 13; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.vchan_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated int32 retirement_fd_indexes = 14; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.retirement_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + // int32 checksum_size = 15; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.checksum_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 metadata_size = 16; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.metadata_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool use_split_buffers = 17; + {PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.use_split_buffers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\41\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.CreateSubscriberResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void CreateSubscriberResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.CreateSubscriberResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.reliable_pub_trigger_fd_indexes_.Clear(); + _impl_.retirement_fd_indexes_.Clear(); + _impl_.error_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + ::memset(&_impl_.channel_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.use_split_buffers_) - + reinterpret_cast(&_impl_.channel_id_)) + sizeof(_impl_.use_split_buffers_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CreateSubscriberResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CreateSubscriberResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CreateSubscriberResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CreateSubscriberResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.CreateSubscriberResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.CreateSubscriberResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_channel_id(), target); + } + + // int32 subscriber_id = 3; + if (this_._internal_subscriber_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_subscriber_id(), target); + } + + // int32 ccb_fd_index = 4; + if (this_._internal_ccb_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_ccb_fd_index(), target); + } + + // int32 bcb_fd_index = 5; + if (this_._internal_bcb_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this_._internal_bcb_fd_index(), target); + } + + // int32 trigger_fd_index = 6; + if (this_._internal_trigger_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this_._internal_trigger_fd_index(), target); + } + + // int32 poll_fd_index = 7; + if (this_._internal_poll_fd_index() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this_._internal_poll_fd_index(), target); + } + + // int32 slot_size = 8; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<8>( + stream, this_._internal_slot_size(), target); + } + + // int32 num_slots = 9; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<9>( + stream, this_._internal_num_slots(), target); + } + + // repeated int32 reliable_pub_trigger_fd_indexes = 10; + { + int byte_size = this_._impl_._reliable_pub_trigger_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 10, this_._internal_reliable_pub_trigger_fd_indexes(), byte_size, target); + } + } + + // int32 num_pub_updates = 11; + if (this_._internal_num_pub_updates() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<11>( + stream, this_._internal_num_pub_updates(), target); + } + + // bytes type = 12; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + target = stream->WriteBytesMaybeAliased(12, _s, target); + } + + // int32 vchan_id = 13; + if (this_._internal_vchan_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this_._internal_vchan_id(), target); + } + + // repeated int32 retirement_fd_indexes = 14; + { + int byte_size = this_._impl_._retirement_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 14, this_._internal_retirement_fd_indexes(), byte_size, target); + } + } + + // int32 checksum_size = 15; + if (this_._internal_checksum_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<15>( + stream, this_._internal_checksum_size(), target); + } + + // int32 metadata_size = 16; + if (this_._internal_metadata_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 16, this_._internal_metadata_size(), target); + } + + // bool use_split_buffers = 17; + if (this_._internal_use_split_buffers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 17, this_._internal_use_split_buffers(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.CreateSubscriberResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CreateSubscriberResponse::ByteSizeLong(const MessageLite& base) { + const CreateSubscriberResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CreateSubscriberResponse::ByteSizeLong() const { + const CreateSubscriberResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.CreateSubscriberResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated int32 reliable_pub_trigger_fd_indexes = 10; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_reliable_pub_trigger_fd_indexes(), 1, + this_._impl_._reliable_pub_trigger_fd_indexes_cached_byte_size_); + } + // repeated int32 retirement_fd_indexes = 14; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_retirement_fd_indexes(), 1, + this_._impl_._retirement_fd_indexes_cached_byte_size_); + } + } + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + // bytes type = 12; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_type()); + } + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_channel_id()); + } + // int32 subscriber_id = 3; + if (this_._internal_subscriber_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_subscriber_id()); + } + // int32 ccb_fd_index = 4; + if (this_._internal_ccb_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_ccb_fd_index()); + } + // int32 bcb_fd_index = 5; + if (this_._internal_bcb_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_bcb_fd_index()); + } + // int32 trigger_fd_index = 6; + if (this_._internal_trigger_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_trigger_fd_index()); + } + // int32 poll_fd_index = 7; + if (this_._internal_poll_fd_index() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_poll_fd_index()); + } + // int32 slot_size = 8; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // int32 num_slots = 9; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + // int32 num_pub_updates = 11; + if (this_._internal_num_pub_updates() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_pub_updates()); + } + // int32 vchan_id = 13; + if (this_._internal_vchan_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_vchan_id()); + } + // int32 checksum_size = 15; + if (this_._internal_checksum_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_checksum_size()); + } + // int32 metadata_size = 16; + if (this_._internal_metadata_size() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int32Size( + this_._internal_metadata_size()); + } + // bool use_split_buffers = 17; + if (this_._internal_use_split_buffers() != 0) { + total_size += 3; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void CreateSubscriberResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.CreateSubscriberResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_reliable_pub_trigger_fd_indexes()->MergeFrom(from._internal_reliable_pub_trigger_fd_indexes()); + _this->_internal_mutable_retirement_fd_indexes()->MergeFrom(from._internal_retirement_fd_indexes()); + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (from._internal_channel_id() != 0) { + _this->_impl_.channel_id_ = from._impl_.channel_id_; + } + if (from._internal_subscriber_id() != 0) { + _this->_impl_.subscriber_id_ = from._impl_.subscriber_id_; + } + if (from._internal_ccb_fd_index() != 0) { + _this->_impl_.ccb_fd_index_ = from._impl_.ccb_fd_index_; + } + if (from._internal_bcb_fd_index() != 0) { + _this->_impl_.bcb_fd_index_ = from._impl_.bcb_fd_index_; + } + if (from._internal_trigger_fd_index() != 0) { + _this->_impl_.trigger_fd_index_ = from._impl_.trigger_fd_index_; + } + if (from._internal_poll_fd_index() != 0) { + _this->_impl_.poll_fd_index_ = from._impl_.poll_fd_index_; + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + if (from._internal_num_pub_updates() != 0) { + _this->_impl_.num_pub_updates_ = from._impl_.num_pub_updates_; + } + if (from._internal_vchan_id() != 0) { + _this->_impl_.vchan_id_ = from._impl_.vchan_id_; + } + if (from._internal_checksum_size() != 0) { + _this->_impl_.checksum_size_ = from._impl_.checksum_size_; + } + if (from._internal_metadata_size() != 0) { + _this->_impl_.metadata_size_ = from._impl_.metadata_size_; + } + if (from._internal_use_split_buffers() != 0) { + _this->_impl_.use_split_buffers_ = from._impl_.use_split_buffers_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void CreateSubscriberResponse::CopyFrom(const CreateSubscriberResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.CreateSubscriberResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CreateSubscriberResponse::InternalSwap(CreateSubscriberResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.reliable_pub_trigger_fd_indexes_.InternalSwap(&other->_impl_.reliable_pub_trigger_fd_indexes_); + _impl_.retirement_fd_indexes_.InternalSwap(&other->_impl_.retirement_fd_indexes_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.use_split_buffers_) + + sizeof(CreateSubscriberResponse::_impl_.use_split_buffers_) + - PROTOBUF_FIELD_OFFSET(CreateSubscriberResponse, _impl_.channel_id_)>( + reinterpret_cast(&_impl_.channel_id_), + reinterpret_cast(&other->_impl_.channel_id_)); +} + +::google::protobuf::Metadata CreateSubscriberResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GetTriggersRequest::_Internal { + public: +}; + +GetTriggersRequest::GetTriggersRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.GetTriggersRequest) +} +inline PROTOBUF_NDEBUG_INLINE GetTriggersRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::GetTriggersRequest& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +GetTriggersRequest::GetTriggersRequest( + ::google::protobuf::Arena* arena, + const GetTriggersRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetTriggersRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.GetTriggersRequest) +} +inline PROTOBUF_NDEBUG_INLINE GetTriggersRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void GetTriggersRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetTriggersRequest::~GetTriggersRequest() { + // @@protoc_insertion_point(destructor:subspace.GetTriggersRequest) + SharedDtor(*this); +} +inline void GetTriggersRequest::SharedDtor(MessageLite& self) { + GetTriggersRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* GetTriggersRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetTriggersRequest(arena); +} +constexpr auto GetTriggersRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(GetTriggersRequest), + alignof(GetTriggersRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull GetTriggersRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_GetTriggersRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetTriggersRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetTriggersRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GetTriggersRequest::ByteSizeLong, + &GetTriggersRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetTriggersRequest, _impl_._cached_size_), + false, + }, + &GetTriggersRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* GetTriggersRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 48, 2> GetTriggersRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::GetTriggersRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetTriggersRequest, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(GetTriggersRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\33\14\0\0\0\0\0\0" + "subspace.GetTriggersRequest" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void GetTriggersRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.GetTriggersRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetTriggersRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetTriggersRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetTriggersRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetTriggersRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.GetTriggersRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.GetTriggersRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.GetTriggersRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetTriggersRequest::ByteSizeLong(const MessageLite& base) { + const GetTriggersRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetTriggersRequest::ByteSizeLong() const { + const GetTriggersRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.GetTriggersRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void GetTriggersRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.GetTriggersRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void GetTriggersRequest::CopyFrom(const GetTriggersRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.GetTriggersRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetTriggersRequest::InternalSwap(GetTriggersRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); +} + +::google::protobuf::Metadata GetTriggersRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GetTriggersResponse::_Internal { + public: +}; + +GetTriggersResponse::GetTriggersResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.GetTriggersResponse) +} +inline PROTOBUF_NDEBUG_INLINE GetTriggersResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::GetTriggersResponse& from_msg) + : reliable_pub_trigger_fd_indexes_{visibility, arena, from.reliable_pub_trigger_fd_indexes_}, + _reliable_pub_trigger_fd_indexes_cached_byte_size_{0}, + sub_trigger_fd_indexes_{visibility, arena, from.sub_trigger_fd_indexes_}, + _sub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{visibility, arena, from.retirement_fd_indexes_}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_(arena, from.error_), + _cached_size_{0} {} + +GetTriggersResponse::GetTriggersResponse( + ::google::protobuf::Arena* arena, + const GetTriggersResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetTriggersResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.GetTriggersResponse) +} +inline PROTOBUF_NDEBUG_INLINE GetTriggersResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : reliable_pub_trigger_fd_indexes_{visibility, arena}, + _reliable_pub_trigger_fd_indexes_cached_byte_size_{0}, + sub_trigger_fd_indexes_{visibility, arena}, + _sub_trigger_fd_indexes_cached_byte_size_{0}, + retirement_fd_indexes_{visibility, arena}, + _retirement_fd_indexes_cached_byte_size_{0}, + error_(arena), + _cached_size_{0} {} + +inline void GetTriggersResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetTriggersResponse::~GetTriggersResponse() { + // @@protoc_insertion_point(destructor:subspace.GetTriggersResponse) + SharedDtor(*this); +} +inline void GetTriggersResponse::SharedDtor(MessageLite& self) { + GetTriggersResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* GetTriggersResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetTriggersResponse(arena); +} +constexpr auto GetTriggersResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.reliable_pub_trigger_fd_indexes_) + + decltype(GetTriggersResponse::_impl_.reliable_pub_trigger_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.sub_trigger_fd_indexes_) + + decltype(GetTriggersResponse::_impl_.sub_trigger_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.retirement_fd_indexes_) + + decltype(GetTriggersResponse::_impl_.retirement_fd_indexes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(GetTriggersResponse), alignof(GetTriggersResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&GetTriggersResponse::PlacementNew_, + sizeof(GetTriggersResponse), + alignof(GetTriggersResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull GetTriggersResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_GetTriggersResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetTriggersResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetTriggersResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GetTriggersResponse::ByteSizeLong, + &GetTriggersResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_._cached_size_), + false, + }, + &GetTriggersResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* GetTriggersResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 42, 2> GetTriggersResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::GetTriggersResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated int32 retirement_fd_indexes = 4; + {::_pbi::TcParser::FastV32P1, + {34, 63, 0, PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.retirement_fd_indexes_)}}, + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.error_)}}, + // repeated int32 reliable_pub_trigger_fd_indexes = 2; + {::_pbi::TcParser::FastV32P1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.reliable_pub_trigger_fd_indexes_)}}, + // repeated int32 sub_trigger_fd_indexes = 3; + {::_pbi::TcParser::FastV32P1, + {26, 63, 0, PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.sub_trigger_fd_indexes_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // repeated int32 reliable_pub_trigger_fd_indexes = 2; + {PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.reliable_pub_trigger_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + // repeated int32 sub_trigger_fd_indexes = 3; + {PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.sub_trigger_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + // repeated int32 retirement_fd_indexes = 4; + {PROTOBUF_FIELD_OFFSET(GetTriggersResponse, _impl_.retirement_fd_indexes_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)}, + }}, + // no aux_entries + {{ + "\34\5\0\0\0\0\0\0" + "subspace.GetTriggersResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void GetTriggersResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.GetTriggersResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.reliable_pub_trigger_fd_indexes_.Clear(); + _impl_.sub_trigger_fd_indexes_.Clear(); + _impl_.retirement_fd_indexes_.Clear(); + _impl_.error_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetTriggersResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetTriggersResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetTriggersResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetTriggersResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.GetTriggersResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.GetTriggersResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // repeated int32 reliable_pub_trigger_fd_indexes = 2; + { + int byte_size = this_._impl_._reliable_pub_trigger_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 2, this_._internal_reliable_pub_trigger_fd_indexes(), byte_size, target); + } + } + + // repeated int32 sub_trigger_fd_indexes = 3; + { + int byte_size = this_._impl_._sub_trigger_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 3, this_._internal_sub_trigger_fd_indexes(), byte_size, target); + } + } + + // repeated int32 retirement_fd_indexes = 4; + { + int byte_size = this_._impl_._retirement_fd_indexes_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 4, this_._internal_retirement_fd_indexes(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.GetTriggersResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetTriggersResponse::ByteSizeLong(const MessageLite& base) { + const GetTriggersResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetTriggersResponse::ByteSizeLong() const { + const GetTriggersResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.GetTriggersResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated int32 reliable_pub_trigger_fd_indexes = 2; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_reliable_pub_trigger_fd_indexes(), 1, + this_._impl_._reliable_pub_trigger_fd_indexes_cached_byte_size_); + } + // repeated int32 sub_trigger_fd_indexes = 3; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_sub_trigger_fd_indexes(), 1, + this_._impl_._sub_trigger_fd_indexes_cached_byte_size_); + } + // repeated int32 retirement_fd_indexes = 4; + { + total_size += + ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize( + this_._internal_retirement_fd_indexes(), 1, + this_._impl_._retirement_fd_indexes_cached_byte_size_); + } + } + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void GetTriggersResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.GetTriggersResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_reliable_pub_trigger_fd_indexes()->MergeFrom(from._internal_reliable_pub_trigger_fd_indexes()); + _this->_internal_mutable_sub_trigger_fd_indexes()->MergeFrom(from._internal_sub_trigger_fd_indexes()); + _this->_internal_mutable_retirement_fd_indexes()->MergeFrom(from._internal_retirement_fd_indexes()); + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void GetTriggersResponse::CopyFrom(const GetTriggersResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.GetTriggersResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetTriggersResponse::InternalSwap(GetTriggersResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.reliable_pub_trigger_fd_indexes_.InternalSwap(&other->_impl_.reliable_pub_trigger_fd_indexes_); + _impl_.sub_trigger_fd_indexes_.InternalSwap(&other->_impl_.sub_trigger_fd_indexes_); + _impl_.retirement_fd_indexes_.InternalSwap(&other->_impl_.retirement_fd_indexes_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); +} + +::google::protobuf::Metadata GetTriggersResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RemovePublisherRequest::_Internal { + public: +}; + +RemovePublisherRequest::RemovePublisherRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RemovePublisherRequest) +} +inline PROTOBUF_NDEBUG_INLINE RemovePublisherRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RemovePublisherRequest& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +RemovePublisherRequest::RemovePublisherRequest( + ::google::protobuf::Arena* arena, + const RemovePublisherRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RemovePublisherRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.publisher_id_ = from._impl_.publisher_id_; + + // @@protoc_insertion_point(copy_constructor:subspace.RemovePublisherRequest) +} +inline PROTOBUF_NDEBUG_INLINE RemovePublisherRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void RemovePublisherRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.publisher_id_ = {}; +} +RemovePublisherRequest::~RemovePublisherRequest() { + // @@protoc_insertion_point(destructor:subspace.RemovePublisherRequest) + SharedDtor(*this); +} +inline void RemovePublisherRequest::SharedDtor(MessageLite& self) { + RemovePublisherRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RemovePublisherRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RemovePublisherRequest(arena); +} +constexpr auto RemovePublisherRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RemovePublisherRequest), + alignof(RemovePublisherRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RemovePublisherRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RemovePublisherRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RemovePublisherRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RemovePublisherRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RemovePublisherRequest::ByteSizeLong, + &RemovePublisherRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RemovePublisherRequest, _impl_._cached_size_), + false, + }, + &RemovePublisherRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RemovePublisherRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 52, 2> RemovePublisherRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RemovePublisherRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 publisher_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RemovePublisherRequest, _impl_.publisher_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RemovePublisherRequest, _impl_.publisher_id_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RemovePublisherRequest, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(RemovePublisherRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 publisher_id = 2; + {PROTOBUF_FIELD_OFFSET(RemovePublisherRequest, _impl_.publisher_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\37\14\0\0\0\0\0\0" + "subspace.RemovePublisherRequest" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void RemovePublisherRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RemovePublisherRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.publisher_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RemovePublisherRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RemovePublisherRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RemovePublisherRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RemovePublisherRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RemovePublisherRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RemovePublisherRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 publisher_id = 2; + if (this_._internal_publisher_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_publisher_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RemovePublisherRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RemovePublisherRequest::ByteSizeLong(const MessageLite& base) { + const RemovePublisherRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RemovePublisherRequest::ByteSizeLong() const { + const RemovePublisherRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RemovePublisherRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 publisher_id = 2; + if (this_._internal_publisher_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_publisher_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RemovePublisherRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RemovePublisherRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_publisher_id() != 0) { + _this->_impl_.publisher_id_ = from._impl_.publisher_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RemovePublisherRequest::CopyFrom(const RemovePublisherRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RemovePublisherRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RemovePublisherRequest::InternalSwap(RemovePublisherRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + swap(_impl_.publisher_id_, other->_impl_.publisher_id_); +} + +::google::protobuf::Metadata RemovePublisherRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RemovePublisherResponse::_Internal { + public: +}; + +RemovePublisherResponse::RemovePublisherResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RemovePublisherResponse) +} +inline PROTOBUF_NDEBUG_INLINE RemovePublisherResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RemovePublisherResponse& from_msg) + : error_(arena, from.error_), + _cached_size_{0} {} + +RemovePublisherResponse::RemovePublisherResponse( + ::google::protobuf::Arena* arena, + const RemovePublisherResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RemovePublisherResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.RemovePublisherResponse) +} +inline PROTOBUF_NDEBUG_INLINE RemovePublisherResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : error_(arena), + _cached_size_{0} {} + +inline void RemovePublisherResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +RemovePublisherResponse::~RemovePublisherResponse() { + // @@protoc_insertion_point(destructor:subspace.RemovePublisherResponse) + SharedDtor(*this); +} +inline void RemovePublisherResponse::SharedDtor(MessageLite& self) { + RemovePublisherResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RemovePublisherResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RemovePublisherResponse(arena); +} +constexpr auto RemovePublisherResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RemovePublisherResponse), + alignof(RemovePublisherResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RemovePublisherResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RemovePublisherResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RemovePublisherResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RemovePublisherResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RemovePublisherResponse::ByteSizeLong, + &RemovePublisherResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RemovePublisherResponse, _impl_._cached_size_), + false, + }, + &RemovePublisherResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RemovePublisherResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 46, 2> RemovePublisherResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RemovePublisherResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RemovePublisherResponse, _impl_.error_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(RemovePublisherResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\40\5\0\0\0\0\0\0" + "subspace.RemovePublisherResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void RemovePublisherResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RemovePublisherResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.error_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RemovePublisherResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RemovePublisherResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RemovePublisherResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RemovePublisherResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RemovePublisherResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RemovePublisherResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RemovePublisherResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RemovePublisherResponse::ByteSizeLong(const MessageLite& base) { + const RemovePublisherResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RemovePublisherResponse::ByteSizeLong() const { + const RemovePublisherResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RemovePublisherResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RemovePublisherResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RemovePublisherResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RemovePublisherResponse::CopyFrom(const RemovePublisherResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RemovePublisherResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RemovePublisherResponse::InternalSwap(RemovePublisherResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); +} + +::google::protobuf::Metadata RemovePublisherResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RemoveSubscriberRequest::_Internal { + public: +}; + +RemoveSubscriberRequest::RemoveSubscriberRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RemoveSubscriberRequest) +} +inline PROTOBUF_NDEBUG_INLINE RemoveSubscriberRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RemoveSubscriberRequest& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +RemoveSubscriberRequest::RemoveSubscriberRequest( + ::google::protobuf::Arena* arena, + const RemoveSubscriberRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RemoveSubscriberRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.subscriber_id_ = from._impl_.subscriber_id_; + + // @@protoc_insertion_point(copy_constructor:subspace.RemoveSubscriberRequest) +} +inline PROTOBUF_NDEBUG_INLINE RemoveSubscriberRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void RemoveSubscriberRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.subscriber_id_ = {}; +} +RemoveSubscriberRequest::~RemoveSubscriberRequest() { + // @@protoc_insertion_point(destructor:subspace.RemoveSubscriberRequest) + SharedDtor(*this); +} +inline void RemoveSubscriberRequest::SharedDtor(MessageLite& self) { + RemoveSubscriberRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RemoveSubscriberRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RemoveSubscriberRequest(arena); +} +constexpr auto RemoveSubscriberRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RemoveSubscriberRequest), + alignof(RemoveSubscriberRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RemoveSubscriberRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RemoveSubscriberRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RemoveSubscriberRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RemoveSubscriberRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RemoveSubscriberRequest::ByteSizeLong, + &RemoveSubscriberRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RemoveSubscriberRequest, _impl_._cached_size_), + false, + }, + &RemoveSubscriberRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RemoveSubscriberRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 53, 2> RemoveSubscriberRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RemoveSubscriberRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 subscriber_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RemoveSubscriberRequest, _impl_.subscriber_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RemoveSubscriberRequest, _impl_.subscriber_id_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RemoveSubscriberRequest, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(RemoveSubscriberRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 subscriber_id = 2; + {PROTOBUF_FIELD_OFFSET(RemoveSubscriberRequest, _impl_.subscriber_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\40\14\0\0\0\0\0\0" + "subspace.RemoveSubscriberRequest" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void RemoveSubscriberRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RemoveSubscriberRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.subscriber_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RemoveSubscriberRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RemoveSubscriberRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RemoveSubscriberRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RemoveSubscriberRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RemoveSubscriberRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RemoveSubscriberRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_subscriber_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RemoveSubscriberRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RemoveSubscriberRequest::ByteSizeLong(const MessageLite& base) { + const RemoveSubscriberRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RemoveSubscriberRequest::ByteSizeLong() const { + const RemoveSubscriberRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RemoveSubscriberRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_subscriber_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RemoveSubscriberRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RemoveSubscriberRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_subscriber_id() != 0) { + _this->_impl_.subscriber_id_ = from._impl_.subscriber_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RemoveSubscriberRequest::CopyFrom(const RemoveSubscriberRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RemoveSubscriberRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RemoveSubscriberRequest::InternalSwap(RemoveSubscriberRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + swap(_impl_.subscriber_id_, other->_impl_.subscriber_id_); +} + +::google::protobuf::Metadata RemoveSubscriberRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RemoveSubscriberResponse::_Internal { + public: +}; + +RemoveSubscriberResponse::RemoveSubscriberResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RemoveSubscriberResponse) +} +inline PROTOBUF_NDEBUG_INLINE RemoveSubscriberResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RemoveSubscriberResponse& from_msg) + : error_(arena, from.error_), + _cached_size_{0} {} + +RemoveSubscriberResponse::RemoveSubscriberResponse( + ::google::protobuf::Arena* arena, + const RemoveSubscriberResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RemoveSubscriberResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.RemoveSubscriberResponse) +} +inline PROTOBUF_NDEBUG_INLINE RemoveSubscriberResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : error_(arena), + _cached_size_{0} {} + +inline void RemoveSubscriberResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +RemoveSubscriberResponse::~RemoveSubscriberResponse() { + // @@protoc_insertion_point(destructor:subspace.RemoveSubscriberResponse) + SharedDtor(*this); +} +inline void RemoveSubscriberResponse::SharedDtor(MessageLite& self) { + RemoveSubscriberResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RemoveSubscriberResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RemoveSubscriberResponse(arena); +} +constexpr auto RemoveSubscriberResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RemoveSubscriberResponse), + alignof(RemoveSubscriberResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RemoveSubscriberResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RemoveSubscriberResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RemoveSubscriberResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RemoveSubscriberResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RemoveSubscriberResponse::ByteSizeLong, + &RemoveSubscriberResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RemoveSubscriberResponse, _impl_._cached_size_), + false, + }, + &RemoveSubscriberResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RemoveSubscriberResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 47, 2> RemoveSubscriberResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RemoveSubscriberResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RemoveSubscriberResponse, _impl_.error_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(RemoveSubscriberResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\41\5\0\0\0\0\0\0" + "subspace.RemoveSubscriberResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void RemoveSubscriberResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RemoveSubscriberResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.error_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RemoveSubscriberResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RemoveSubscriberResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RemoveSubscriberResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RemoveSubscriberResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RemoveSubscriberResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RemoveSubscriberResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RemoveSubscriberResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RemoveSubscriberResponse::ByteSizeLong(const MessageLite& base) { + const RemoveSubscriberResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RemoveSubscriberResponse::ByteSizeLong() const { + const RemoveSubscriberResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RemoveSubscriberResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RemoveSubscriberResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RemoveSubscriberResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RemoveSubscriberResponse::CopyFrom(const RemoveSubscriberResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RemoveSubscriberResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RemoveSubscriberResponse::InternalSwap(RemoveSubscriberResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); +} + +::google::protobuf::Metadata RemoveSubscriberResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GetChannelInfoRequest::_Internal { + public: +}; + +GetChannelInfoRequest::GetChannelInfoRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.GetChannelInfoRequest) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelInfoRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::GetChannelInfoRequest& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +GetChannelInfoRequest::GetChannelInfoRequest( + ::google::protobuf::Arena* arena, + const GetChannelInfoRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetChannelInfoRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.GetChannelInfoRequest) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelInfoRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void GetChannelInfoRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetChannelInfoRequest::~GetChannelInfoRequest() { + // @@protoc_insertion_point(destructor:subspace.GetChannelInfoRequest) + SharedDtor(*this); +} +inline void GetChannelInfoRequest::SharedDtor(MessageLite& self) { + GetChannelInfoRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* GetChannelInfoRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetChannelInfoRequest(arena); +} +constexpr auto GetChannelInfoRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(GetChannelInfoRequest), + alignof(GetChannelInfoRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull GetChannelInfoRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_GetChannelInfoRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetChannelInfoRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetChannelInfoRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GetChannelInfoRequest::ByteSizeLong, + &GetChannelInfoRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetChannelInfoRequest, _impl_._cached_size_), + false, + }, + &GetChannelInfoRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* GetChannelInfoRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 51, 2> GetChannelInfoRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::GetChannelInfoRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetChannelInfoRequest, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(GetChannelInfoRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\36\14\0\0\0\0\0\0" + "subspace.GetChannelInfoRequest" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void GetChannelInfoRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.GetChannelInfoRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetChannelInfoRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetChannelInfoRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetChannelInfoRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetChannelInfoRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.GetChannelInfoRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.GetChannelInfoRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.GetChannelInfoRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetChannelInfoRequest::ByteSizeLong(const MessageLite& base) { + const GetChannelInfoRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetChannelInfoRequest::ByteSizeLong() const { + const GetChannelInfoRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.GetChannelInfoRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void GetChannelInfoRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.GetChannelInfoRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void GetChannelInfoRequest::CopyFrom(const GetChannelInfoRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.GetChannelInfoRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetChannelInfoRequest::InternalSwap(GetChannelInfoRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); +} + +::google::protobuf::Metadata GetChannelInfoRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GetChannelInfoResponse::_Internal { + public: +}; + +GetChannelInfoResponse::GetChannelInfoResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.GetChannelInfoResponse) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelInfoResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::GetChannelInfoResponse& from_msg) + : channels_{visibility, arena, from.channels_}, + error_(arena, from.error_), + _cached_size_{0} {} + +GetChannelInfoResponse::GetChannelInfoResponse( + ::google::protobuf::Arena* arena, + const GetChannelInfoResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetChannelInfoResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.GetChannelInfoResponse) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelInfoResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channels_{visibility, arena}, + error_(arena), + _cached_size_{0} {} + +inline void GetChannelInfoResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetChannelInfoResponse::~GetChannelInfoResponse() { + // @@protoc_insertion_point(destructor:subspace.GetChannelInfoResponse) + SharedDtor(*this); +} +inline void GetChannelInfoResponse::SharedDtor(MessageLite& self) { + GetChannelInfoResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* GetChannelInfoResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetChannelInfoResponse(arena); +} +constexpr auto GetChannelInfoResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(GetChannelInfoResponse, _impl_.channels_) + + decltype(GetChannelInfoResponse::_impl_.channels_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(GetChannelInfoResponse), alignof(GetChannelInfoResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&GetChannelInfoResponse::PlacementNew_, + sizeof(GetChannelInfoResponse), + alignof(GetChannelInfoResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull GetChannelInfoResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_GetChannelInfoResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetChannelInfoResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetChannelInfoResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GetChannelInfoResponse::ByteSizeLong, + &GetChannelInfoResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetChannelInfoResponse, _impl_._cached_size_), + false, + }, + &GetChannelInfoResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* GetChannelInfoResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 45, 2> GetChannelInfoResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::GetChannelInfoResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .subspace.ChannelInfoProto channels = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(GetChannelInfoResponse, _impl_.channels_)}}, + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetChannelInfoResponse, _impl_.error_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(GetChannelInfoResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // repeated .subspace.ChannelInfoProto channels = 2; + {PROTOBUF_FIELD_OFFSET(GetChannelInfoResponse, _impl_.channels_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ChannelInfoProto>()}, + }}, {{ + "\37\5\0\0\0\0\0\0" + "subspace.GetChannelInfoResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void GetChannelInfoResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.GetChannelInfoResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channels_.Clear(); + _impl_.error_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetChannelInfoResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetChannelInfoResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetChannelInfoResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetChannelInfoResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.GetChannelInfoResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.GetChannelInfoResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // repeated .subspace.ChannelInfoProto channels = 2; + for (unsigned i = 0, n = static_cast( + this_._internal_channels_size()); + i < n; i++) { + const auto& repfield = this_._internal_channels().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.GetChannelInfoResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetChannelInfoResponse::ByteSizeLong(const MessageLite& base) { + const GetChannelInfoResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetChannelInfoResponse::ByteSizeLong() const { + const GetChannelInfoResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.GetChannelInfoResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .subspace.ChannelInfoProto channels = 2; + { + total_size += 1UL * this_._internal_channels_size(); + for (const auto& msg : this_._internal_channels()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void GetChannelInfoResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.GetChannelInfoResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_channels()->MergeFrom( + from._internal_channels()); + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void GetChannelInfoResponse::CopyFrom(const GetChannelInfoResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.GetChannelInfoResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetChannelInfoResponse::InternalSwap(GetChannelInfoResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.channels_.InternalSwap(&other->_impl_.channels_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); +} + +::google::protobuf::Metadata GetChannelInfoResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GetChannelStatsRequest::_Internal { + public: +}; + +GetChannelStatsRequest::GetChannelStatsRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.GetChannelStatsRequest) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelStatsRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::GetChannelStatsRequest& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +GetChannelStatsRequest::GetChannelStatsRequest( + ::google::protobuf::Arena* arena, + const GetChannelStatsRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetChannelStatsRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.GetChannelStatsRequest) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelStatsRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void GetChannelStatsRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetChannelStatsRequest::~GetChannelStatsRequest() { + // @@protoc_insertion_point(destructor:subspace.GetChannelStatsRequest) + SharedDtor(*this); +} +inline void GetChannelStatsRequest::SharedDtor(MessageLite& self) { + GetChannelStatsRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* GetChannelStatsRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetChannelStatsRequest(arena); +} +constexpr auto GetChannelStatsRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(GetChannelStatsRequest), + alignof(GetChannelStatsRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull GetChannelStatsRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_GetChannelStatsRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetChannelStatsRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetChannelStatsRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GetChannelStatsRequest::ByteSizeLong, + &GetChannelStatsRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetChannelStatsRequest, _impl_._cached_size_), + false, + }, + &GetChannelStatsRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* GetChannelStatsRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 52, 2> GetChannelStatsRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::GetChannelStatsRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetChannelStatsRequest, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(GetChannelStatsRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\37\14\0\0\0\0\0\0" + "subspace.GetChannelStatsRequest" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void GetChannelStatsRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.GetChannelStatsRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetChannelStatsRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetChannelStatsRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetChannelStatsRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetChannelStatsRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.GetChannelStatsRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.GetChannelStatsRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.GetChannelStatsRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetChannelStatsRequest::ByteSizeLong(const MessageLite& base) { + const GetChannelStatsRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetChannelStatsRequest::ByteSizeLong() const { + const GetChannelStatsRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.GetChannelStatsRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void GetChannelStatsRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.GetChannelStatsRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void GetChannelStatsRequest::CopyFrom(const GetChannelStatsRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.GetChannelStatsRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetChannelStatsRequest::InternalSwap(GetChannelStatsRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); +} + +::google::protobuf::Metadata GetChannelStatsRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GetChannelStatsResponse::_Internal { + public: +}; + +GetChannelStatsResponse::GetChannelStatsResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.GetChannelStatsResponse) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelStatsResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::GetChannelStatsResponse& from_msg) + : channels_{visibility, arena, from.channels_}, + error_(arena, from.error_), + _cached_size_{0} {} + +GetChannelStatsResponse::GetChannelStatsResponse( + ::google::protobuf::Arena* arena, + const GetChannelStatsResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetChannelStatsResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.GetChannelStatsResponse) +} +inline PROTOBUF_NDEBUG_INLINE GetChannelStatsResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channels_{visibility, arena}, + error_(arena), + _cached_size_{0} {} + +inline void GetChannelStatsResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetChannelStatsResponse::~GetChannelStatsResponse() { + // @@protoc_insertion_point(destructor:subspace.GetChannelStatsResponse) + SharedDtor(*this); +} +inline void GetChannelStatsResponse::SharedDtor(MessageLite& self) { + GetChannelStatsResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* GetChannelStatsResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetChannelStatsResponse(arena); +} +constexpr auto GetChannelStatsResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(GetChannelStatsResponse, _impl_.channels_) + + decltype(GetChannelStatsResponse::_impl_.channels_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(GetChannelStatsResponse), alignof(GetChannelStatsResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&GetChannelStatsResponse::PlacementNew_, + sizeof(GetChannelStatsResponse), + alignof(GetChannelStatsResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull GetChannelStatsResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_GetChannelStatsResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetChannelStatsResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetChannelStatsResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GetChannelStatsResponse::ByteSizeLong, + &GetChannelStatsResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetChannelStatsResponse, _impl_._cached_size_), + false, + }, + &GetChannelStatsResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* GetChannelStatsResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 46, 2> GetChannelStatsResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::GetChannelStatsResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .subspace.ChannelStatsProto channels = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(GetChannelStatsResponse, _impl_.channels_)}}, + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetChannelStatsResponse, _impl_.error_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(GetChannelStatsResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // repeated .subspace.ChannelStatsProto channels = 2; + {PROTOBUF_FIELD_OFFSET(GetChannelStatsResponse, _impl_.channels_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ChannelStatsProto>()}, + }}, {{ + "\40\5\0\0\0\0\0\0" + "subspace.GetChannelStatsResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void GetChannelStatsResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.GetChannelStatsResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channels_.Clear(); + _impl_.error_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetChannelStatsResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetChannelStatsResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetChannelStatsResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetChannelStatsResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.GetChannelStatsResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.GetChannelStatsResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // repeated .subspace.ChannelStatsProto channels = 2; + for (unsigned i = 0, n = static_cast( + this_._internal_channels_size()); + i < n; i++) { + const auto& repfield = this_._internal_channels().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.GetChannelStatsResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetChannelStatsResponse::ByteSizeLong(const MessageLite& base) { + const GetChannelStatsResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetChannelStatsResponse::ByteSizeLong() const { + const GetChannelStatsResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.GetChannelStatsResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .subspace.ChannelStatsProto channels = 2; + { + total_size += 1UL * this_._internal_channels_size(); + for (const auto& msg : this_._internal_channels()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void GetChannelStatsResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.GetChannelStatsResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_channels()->MergeFrom( + from._internal_channels()); + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void GetChannelStatsResponse::CopyFrom(const GetChannelStatsResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.GetChannelStatsResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetChannelStatsResponse::InternalSwap(GetChannelStatsResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.channels_.InternalSwap(&other->_impl_.channels_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); +} + +::google::protobuf::Metadata GetChannelStatsResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ClientBufferHandleMetadataProto::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_._has_bits_); +}; + +void ClientBufferHandleMetadataProto::clear_allocator_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.allocator_metadata_ != nullptr) _impl_.allocator_metadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +ClientBufferHandleMetadataProto::ClientBufferHandleMetadataProto(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ClientBufferHandleMetadataProto) +} +inline PROTOBUF_NDEBUG_INLINE ClientBufferHandleMetadataProto::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ClientBufferHandleMetadataProto& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + channel_name_(arena, from.channel_name_), + shadow_file_(arena, from.shadow_file_), + object_name_(arena, from.object_name_), + allocator_(arena, from.allocator_), + pool_id_(arena, from.pool_id_) {} + +ClientBufferHandleMetadataProto::ClientBufferHandleMetadataProto( + ::google::protobuf::Arena* arena, + const ClientBufferHandleMetadataProto& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ClientBufferHandleMetadataProto* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.allocator_metadata_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::google::protobuf::Any>( + arena, *from._impl_.allocator_metadata_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, session_id_), + offsetof(Impl_, alignment_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::alignment_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ClientBufferHandleMetadataProto) +} +inline PROTOBUF_NDEBUG_INLINE ClientBufferHandleMetadataProto::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + channel_name_(arena), + shadow_file_(arena), + object_name_(arena), + allocator_(arena), + pool_id_(arena) {} + +inline void ClientBufferHandleMetadataProto::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, allocator_metadata_), + 0, + offsetof(Impl_, alignment_) - + offsetof(Impl_, allocator_metadata_) + + sizeof(Impl_::alignment_)); +} +ClientBufferHandleMetadataProto::~ClientBufferHandleMetadataProto() { + // @@protoc_insertion_point(destructor:subspace.ClientBufferHandleMetadataProto) + SharedDtor(*this); +} +inline void ClientBufferHandleMetadataProto::SharedDtor(MessageLite& self) { + ClientBufferHandleMetadataProto& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.shadow_file_.Destroy(); + this_._impl_.object_name_.Destroy(); + this_._impl_.allocator_.Destroy(); + this_._impl_.pool_id_.Destroy(); + delete this_._impl_.allocator_metadata_; + this_._impl_.~Impl_(); +} + +inline void* ClientBufferHandleMetadataProto::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ClientBufferHandleMetadataProto(arena); +} +constexpr auto ClientBufferHandleMetadataProto::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClientBufferHandleMetadataProto), + alignof(ClientBufferHandleMetadataProto)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ClientBufferHandleMetadataProto::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ClientBufferHandleMetadataProto_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClientBufferHandleMetadataProto::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClientBufferHandleMetadataProto::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ClientBufferHandleMetadataProto::ByteSizeLong, + &ClientBufferHandleMetadataProto::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_._cached_size_), + false, + }, + &ClientBufferHandleMetadataProto::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ClientBufferHandleMetadataProto::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 15, 1, 107, 2> ClientBufferHandleMetadataProto::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_._has_bits_), + 0, // no _extensions_ + 15, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294934528, // skipmap + offsetof(decltype(_table_), field_entries), + 15, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ClientBufferHandleMetadataProto>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.channel_name_)}}, + // uint64 session_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ClientBufferHandleMetadataProto, _impl_.session_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.session_id_)}}, + // uint32 buffer_index = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ClientBufferHandleMetadataProto, _impl_.buffer_index_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.buffer_index_)}}, + // uint32 slot_id = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ClientBufferHandleMetadataProto, _impl_.slot_id_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.slot_id_)}}, + // bool is_prefix = 5; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.is_prefix_)}}, + // uint64 full_size = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ClientBufferHandleMetadataProto, _impl_.full_size_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.full_size_)}}, + // uint64 allocation_size = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ClientBufferHandleMetadataProto, _impl_.allocation_size_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocation_size_)}}, + // uint64 handle = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ClientBufferHandleMetadataProto, _impl_.handle_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.handle_)}}, + // string shadow_file = 9; + {::_pbi::TcParser::FastUS1, + {74, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.shadow_file_)}}, + // string object_name = 10; + {::_pbi::TcParser::FastUS1, + {82, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.object_name_)}}, + // string allocator = 11; + {::_pbi::TcParser::FastUS1, + {90, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocator_)}}, + // string pool_id = 12; + {::_pbi::TcParser::FastUS1, + {98, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.pool_id_)}}, + // bool cache_enabled = 13; + {::_pbi::TcParser::SingularVarintNoZag1(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.cache_enabled_)}}, + // uint32 alignment = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ClientBufferHandleMetadataProto, _impl_.alignment_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.alignment_)}}, + // .google.protobuf.Any allocator_metadata = 15; + {::_pbi::TcParser::FastMtS1, + {122, 0, 0, PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocator_metadata_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.channel_name_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint64 session_id = 2; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.session_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint32 buffer_index = 3; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.buffer_index_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 slot_id = 4; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.slot_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // bool is_prefix = 5; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.is_prefix_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint64 full_size = 6; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.full_size_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint64 allocation_size = 7; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocation_size_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint64 handle = 8; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.handle_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // string shadow_file = 9; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.shadow_file_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string object_name = 10; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.object_name_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string allocator = 11; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocator_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string pool_id = 12; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.pool_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool cache_enabled = 13; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.cache_enabled_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 alignment = 14; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.alignment_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // .google.protobuf.Any allocator_metadata = 15; + {PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocator_metadata_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + }}, {{ + "\50\14\0\0\0\0\0\0\0\13\13\11\7\0\0\0" + "subspace.ClientBufferHandleMetadataProto" + "channel_name" + "shadow_file" + "object_name" + "allocator" + "pool_id" + }}, +}; + +PROTOBUF_NOINLINE void ClientBufferHandleMetadataProto::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ClientBufferHandleMetadataProto) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.shadow_file_.ClearToEmpty(); + _impl_.object_name_.ClearToEmpty(); + _impl_.allocator_.ClearToEmpty(); + _impl_.pool_id_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.allocator_metadata_ != nullptr); + _impl_.allocator_metadata_->Clear(); + } + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.alignment_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.alignment_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ClientBufferHandleMetadataProto::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ClientBufferHandleMetadataProto& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ClientBufferHandleMetadataProto::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ClientBufferHandleMetadataProto& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ClientBufferHandleMetadataProto) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ClientBufferHandleMetadataProto.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // uint64 session_id = 2; + if (this_._internal_session_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 2, this_._internal_session_id(), target); + } + + // uint32 buffer_index = 3; + if (this_._internal_buffer_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this_._internal_buffer_index(), target); + } + + // uint32 slot_id = 4; + if (this_._internal_slot_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 4, this_._internal_slot_id(), target); + } + + // bool is_prefix = 5; + if (this_._internal_is_prefix() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_is_prefix(), target); + } + + // uint64 full_size = 6; + if (this_._internal_full_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 6, this_._internal_full_size(), target); + } + + // uint64 allocation_size = 7; + if (this_._internal_allocation_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 7, this_._internal_allocation_size(), target); + } + + // uint64 handle = 8; + if (this_._internal_handle() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 8, this_._internal_handle(), target); + } + + // string shadow_file = 9; + if (!this_._internal_shadow_file().empty()) { + const std::string& _s = this_._internal_shadow_file(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ClientBufferHandleMetadataProto.shadow_file"); + target = stream->WriteStringMaybeAliased(9, _s, target); + } + + // string object_name = 10; + if (!this_._internal_object_name().empty()) { + const std::string& _s = this_._internal_object_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ClientBufferHandleMetadataProto.object_name"); + target = stream->WriteStringMaybeAliased(10, _s, target); + } + + // string allocator = 11; + if (!this_._internal_allocator().empty()) { + const std::string& _s = this_._internal_allocator(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ClientBufferHandleMetadataProto.allocator"); + target = stream->WriteStringMaybeAliased(11, _s, target); + } + + // string pool_id = 12; + if (!this_._internal_pool_id().empty()) { + const std::string& _s = this_._internal_pool_id(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ClientBufferHandleMetadataProto.pool_id"); + target = stream->WriteStringMaybeAliased(12, _s, target); + } + + // bool cache_enabled = 13; + if (this_._internal_cache_enabled() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 13, this_._internal_cache_enabled(), target); + } + + // uint32 alignment = 14; + if (this_._internal_alignment() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 14, this_._internal_alignment(), target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .google.protobuf.Any allocator_metadata = 15; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 15, *this_._impl_.allocator_metadata_, this_._impl_.allocator_metadata_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ClientBufferHandleMetadataProto) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ClientBufferHandleMetadataProto::ByteSizeLong(const MessageLite& base) { + const ClientBufferHandleMetadataProto& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ClientBufferHandleMetadataProto::ByteSizeLong() const { + const ClientBufferHandleMetadataProto& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ClientBufferHandleMetadataProto) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // string shadow_file = 9; + if (!this_._internal_shadow_file().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_shadow_file()); + } + // string object_name = 10; + if (!this_._internal_object_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_object_name()); + } + // string allocator = 11; + if (!this_._internal_allocator().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_allocator()); + } + // string pool_id = 12; + if (!this_._internal_pool_id().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_pool_id()); + } + } + { + // .google.protobuf.Any allocator_metadata = 15; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.allocator_metadata_); + } + } + { + // uint64 session_id = 2; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_session_id()); + } + // uint32 buffer_index = 3; + if (this_._internal_buffer_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_buffer_index()); + } + // uint32 slot_id = 4; + if (this_._internal_slot_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_slot_id()); + } + // uint64 full_size = 6; + if (this_._internal_full_size() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_full_size()); + } + // uint64 allocation_size = 7; + if (this_._internal_allocation_size() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_allocation_size()); + } + // uint64 handle = 8; + if (this_._internal_handle() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_handle()); + } + // bool is_prefix = 5; + if (this_._internal_is_prefix() != 0) { + total_size += 2; + } + // bool cache_enabled = 13; + if (this_._internal_cache_enabled() != 0) { + total_size += 2; + } + // uint32 alignment = 14; + if (this_._internal_alignment() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_alignment()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ClientBufferHandleMetadataProto::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ClientBufferHandleMetadataProto) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (!from._internal_shadow_file().empty()) { + _this->_internal_set_shadow_file(from._internal_shadow_file()); + } + if (!from._internal_object_name().empty()) { + _this->_internal_set_object_name(from._internal_object_name()); + } + if (!from._internal_allocator().empty()) { + _this->_internal_set_allocator(from._internal_allocator()); + } + if (!from._internal_pool_id().empty()) { + _this->_internal_set_pool_id(from._internal_pool_id()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.allocator_metadata_ != nullptr); + if (_this->_impl_.allocator_metadata_ == nullptr) { + _this->_impl_.allocator_metadata_ = + ::google::protobuf::Message::CopyConstruct<::google::protobuf::Any>(arena, *from._impl_.allocator_metadata_); + } else { + _this->_impl_.allocator_metadata_->MergeFrom(*from._impl_.allocator_metadata_); + } + } + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_buffer_index() != 0) { + _this->_impl_.buffer_index_ = from._impl_.buffer_index_; + } + if (from._internal_slot_id() != 0) { + _this->_impl_.slot_id_ = from._impl_.slot_id_; + } + if (from._internal_full_size() != 0) { + _this->_impl_.full_size_ = from._impl_.full_size_; + } + if (from._internal_allocation_size() != 0) { + _this->_impl_.allocation_size_ = from._impl_.allocation_size_; + } + if (from._internal_handle() != 0) { + _this->_impl_.handle_ = from._impl_.handle_; + } + if (from._internal_is_prefix() != 0) { + _this->_impl_.is_prefix_ = from._impl_.is_prefix_; + } + if (from._internal_cache_enabled() != 0) { + _this->_impl_.cache_enabled_ = from._impl_.cache_enabled_; + } + if (from._internal_alignment() != 0) { + _this->_impl_.alignment_ = from._impl_.alignment_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientBufferHandleMetadataProto::CopyFrom(const ClientBufferHandleMetadataProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ClientBufferHandleMetadataProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ClientBufferHandleMetadataProto::InternalSwap(ClientBufferHandleMetadataProto* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.shadow_file_, &other->_impl_.shadow_file_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.object_name_, &other->_impl_.object_name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.allocator_, &other->_impl_.allocator_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.pool_id_, &other->_impl_.pool_id_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.alignment_) + + sizeof(ClientBufferHandleMetadataProto::_impl_.alignment_) + - PROTOBUF_FIELD_OFFSET(ClientBufferHandleMetadataProto, _impl_.allocator_metadata_)>( + reinterpret_cast(&_impl_.allocator_metadata_), + reinterpret_cast(&other->_impl_.allocator_metadata_)); +} + +::google::protobuf::Metadata ClientBufferHandleMetadataProto::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RegisterClientBufferRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RegisterClientBufferRequest, _impl_._has_bits_); +}; + +RegisterClientBufferRequest::RegisterClientBufferRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RegisterClientBufferRequest) +} +inline PROTOBUF_NDEBUG_INLINE RegisterClientBufferRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RegisterClientBufferRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +RegisterClientBufferRequest::RegisterClientBufferRequest( + ::google::protobuf::Arena* arena, + const RegisterClientBufferRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RegisterClientBufferRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.metadata_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::subspace::ClientBufferHandleMetadataProto>( + arena, *from._impl_.metadata_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:subspace.RegisterClientBufferRequest) +} +inline PROTOBUF_NDEBUG_INLINE RegisterClientBufferRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RegisterClientBufferRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.metadata_ = {}; +} +RegisterClientBufferRequest::~RegisterClientBufferRequest() { + // @@protoc_insertion_point(destructor:subspace.RegisterClientBufferRequest) + SharedDtor(*this); +} +inline void RegisterClientBufferRequest::SharedDtor(MessageLite& self) { + RegisterClientBufferRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.metadata_; + this_._impl_.~Impl_(); +} + +inline void* RegisterClientBufferRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RegisterClientBufferRequest(arena); +} +constexpr auto RegisterClientBufferRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RegisterClientBufferRequest), + alignof(RegisterClientBufferRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RegisterClientBufferRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RegisterClientBufferRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RegisterClientBufferRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RegisterClientBufferRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RegisterClientBufferRequest::ByteSizeLong, + &RegisterClientBufferRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RegisterClientBufferRequest, _impl_._cached_size_), + false, + }, + &RegisterClientBufferRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RegisterClientBufferRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> RegisterClientBufferRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RegisterClientBufferRequest, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RegisterClientBufferRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(RegisterClientBufferRequest, _impl_.metadata_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + {PROTOBUF_FIELD_OFFSET(RegisterClientBufferRequest, _impl_.metadata_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ClientBufferHandleMetadataProto>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void RegisterClientBufferRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RegisterClientBufferRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.metadata_ != nullptr); + _impl_.metadata_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RegisterClientBufferRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RegisterClientBufferRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RegisterClientBufferRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RegisterClientBufferRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RegisterClientBufferRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.metadata_, this_._impl_.metadata_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RegisterClientBufferRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RegisterClientBufferRequest::ByteSizeLong(const MessageLite& base) { + const RegisterClientBufferRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RegisterClientBufferRequest::ByteSizeLong() const { + const RegisterClientBufferRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RegisterClientBufferRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.metadata_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RegisterClientBufferRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RegisterClientBufferRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.metadata_ != nullptr); + if (_this->_impl_.metadata_ == nullptr) { + _this->_impl_.metadata_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ClientBufferHandleMetadataProto>(arena, *from._impl_.metadata_); + } else { + _this->_impl_.metadata_->MergeFrom(*from._impl_.metadata_); + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RegisterClientBufferRequest::CopyFrom(const RegisterClientBufferRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RegisterClientBufferRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RegisterClientBufferRequest::InternalSwap(RegisterClientBufferRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.metadata_, other->_impl_.metadata_); +} + +::google::protobuf::Metadata RegisterClientBufferRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class UnregisterClientBufferRequest::_Internal { + public: +}; + +UnregisterClientBufferRequest::UnregisterClientBufferRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.UnregisterClientBufferRequest) +} +inline PROTOBUF_NDEBUG_INLINE UnregisterClientBufferRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::UnregisterClientBufferRequest& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +UnregisterClientBufferRequest::UnregisterClientBufferRequest( + ::google::protobuf::Arena* arena, + const UnregisterClientBufferRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + UnregisterClientBufferRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, session_id_), + offsetof(Impl_, buffer_index_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::buffer_index_)); + + // @@protoc_insertion_point(copy_constructor:subspace.UnregisterClientBufferRequest) +} +inline PROTOBUF_NDEBUG_INLINE UnregisterClientBufferRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void UnregisterClientBufferRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + 0, + offsetof(Impl_, buffer_index_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::buffer_index_)); +} +UnregisterClientBufferRequest::~UnregisterClientBufferRequest() { + // @@protoc_insertion_point(destructor:subspace.UnregisterClientBufferRequest) + SharedDtor(*this); +} +inline void UnregisterClientBufferRequest::SharedDtor(MessageLite& self) { + UnregisterClientBufferRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* UnregisterClientBufferRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UnregisterClientBufferRequest(arena); +} +constexpr auto UnregisterClientBufferRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(UnregisterClientBufferRequest), + alignof(UnregisterClientBufferRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull UnregisterClientBufferRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_UnregisterClientBufferRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UnregisterClientBufferRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UnregisterClientBufferRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &UnregisterClientBufferRequest::ByteSizeLong, + &UnregisterClientBufferRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_._cached_size_), + false, + }, + &UnregisterClientBufferRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* UnregisterClientBufferRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 59, 2> UnregisterClientBufferRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::UnregisterClientBufferRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.channel_name_)}}, + // uint64 session_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(UnregisterClientBufferRequest, _impl_.session_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.session_id_)}}, + // uint32 buffer_index = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(UnregisterClientBufferRequest, _impl_.buffer_index_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.buffer_index_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint64 session_id = 2; + {PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint32 buffer_index = 3; + {PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.buffer_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + "\46\14\0\0\0\0\0\0" + "subspace.UnregisterClientBufferRequest" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void UnregisterClientBufferRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.UnregisterClientBufferRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.buffer_index_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.buffer_index_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* UnregisterClientBufferRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const UnregisterClientBufferRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* UnregisterClientBufferRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const UnregisterClientBufferRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.UnregisterClientBufferRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.UnregisterClientBufferRequest.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // uint64 session_id = 2; + if (this_._internal_session_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 2, this_._internal_session_id(), target); + } + + // uint32 buffer_index = 3; + if (this_._internal_buffer_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this_._internal_buffer_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.UnregisterClientBufferRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t UnregisterClientBufferRequest::ByteSizeLong(const MessageLite& base) { + const UnregisterClientBufferRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t UnregisterClientBufferRequest::ByteSizeLong() const { + const UnregisterClientBufferRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.UnregisterClientBufferRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // uint64 session_id = 2; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_session_id()); + } + // uint32 buffer_index = 3; + if (this_._internal_buffer_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_buffer_index()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void UnregisterClientBufferRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.UnregisterClientBufferRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_buffer_index() != 0) { + _this->_impl_.buffer_index_ = from._impl_.buffer_index_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void UnregisterClientBufferRequest::CopyFrom(const UnregisterClientBufferRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.UnregisterClientBufferRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void UnregisterClientBufferRequest::InternalSwap(UnregisterClientBufferRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.buffer_index_) + + sizeof(UnregisterClientBufferRequest::_impl_.buffer_index_) + - PROTOBUF_FIELD_OFFSET(UnregisterClientBufferRequest, _impl_.session_id_)>( + reinterpret_cast(&_impl_.session_id_), + reinterpret_cast(&other->_impl_.session_id_)); +} + +::google::protobuf::Metadata UnregisterClientBufferRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Request::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::subspace::Request, _impl_._oneof_case_); +}; + +void Request::set_allocated_init(::subspace::InitRequest* init) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (init) { + ::google::protobuf::Arena* submessage_arena = init->GetArena(); + if (message_arena != submessage_arena) { + init = ::google::protobuf::internal::GetOwnedMessage(message_arena, init, submessage_arena); + } + set_has_init(); + _impl_.request_.init_ = init; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.init) +} +void Request::set_allocated_create_publisher(::subspace::CreatePublisherRequest* create_publisher) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (create_publisher) { + ::google::protobuf::Arena* submessage_arena = create_publisher->GetArena(); + if (message_arena != submessage_arena) { + create_publisher = ::google::protobuf::internal::GetOwnedMessage(message_arena, create_publisher, submessage_arena); + } + set_has_create_publisher(); + _impl_.request_.create_publisher_ = create_publisher; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.create_publisher) +} +void Request::set_allocated_create_subscriber(::subspace::CreateSubscriberRequest* create_subscriber) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (create_subscriber) { + ::google::protobuf::Arena* submessage_arena = create_subscriber->GetArena(); + if (message_arena != submessage_arena) { + create_subscriber = ::google::protobuf::internal::GetOwnedMessage(message_arena, create_subscriber, submessage_arena); + } + set_has_create_subscriber(); + _impl_.request_.create_subscriber_ = create_subscriber; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.create_subscriber) +} +void Request::set_allocated_get_triggers(::subspace::GetTriggersRequest* get_triggers) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (get_triggers) { + ::google::protobuf::Arena* submessage_arena = get_triggers->GetArena(); + if (message_arena != submessage_arena) { + get_triggers = ::google::protobuf::internal::GetOwnedMessage(message_arena, get_triggers, submessage_arena); + } + set_has_get_triggers(); + _impl_.request_.get_triggers_ = get_triggers; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.get_triggers) +} +void Request::set_allocated_remove_publisher(::subspace::RemovePublisherRequest* remove_publisher) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (remove_publisher) { + ::google::protobuf::Arena* submessage_arena = remove_publisher->GetArena(); + if (message_arena != submessage_arena) { + remove_publisher = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_publisher, submessage_arena); + } + set_has_remove_publisher(); + _impl_.request_.remove_publisher_ = remove_publisher; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.remove_publisher) +} +void Request::set_allocated_remove_subscriber(::subspace::RemoveSubscriberRequest* remove_subscriber) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (remove_subscriber) { + ::google::protobuf::Arena* submessage_arena = remove_subscriber->GetArena(); + if (message_arena != submessage_arena) { + remove_subscriber = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_subscriber, submessage_arena); + } + set_has_remove_subscriber(); + _impl_.request_.remove_subscriber_ = remove_subscriber; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.remove_subscriber) +} +void Request::set_allocated_get_channel_info(::subspace::GetChannelInfoRequest* get_channel_info) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (get_channel_info) { + ::google::protobuf::Arena* submessage_arena = get_channel_info->GetArena(); + if (message_arena != submessage_arena) { + get_channel_info = ::google::protobuf::internal::GetOwnedMessage(message_arena, get_channel_info, submessage_arena); + } + set_has_get_channel_info(); + _impl_.request_.get_channel_info_ = get_channel_info; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.get_channel_info) +} +void Request::set_allocated_get_channel_stats(::subspace::GetChannelStatsRequest* get_channel_stats) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (get_channel_stats) { + ::google::protobuf::Arena* submessage_arena = get_channel_stats->GetArena(); + if (message_arena != submessage_arena) { + get_channel_stats = ::google::protobuf::internal::GetOwnedMessage(message_arena, get_channel_stats, submessage_arena); + } + set_has_get_channel_stats(); + _impl_.request_.get_channel_stats_ = get_channel_stats; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.get_channel_stats) +} +void Request::set_allocated_register_client_buffer(::subspace::RegisterClientBufferRequest* register_client_buffer) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (register_client_buffer) { + ::google::protobuf::Arena* submessage_arena = register_client_buffer->GetArena(); + if (message_arena != submessage_arena) { + register_client_buffer = ::google::protobuf::internal::GetOwnedMessage(message_arena, register_client_buffer, submessage_arena); + } + set_has_register_client_buffer(); + _impl_.request_.register_client_buffer_ = register_client_buffer; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.register_client_buffer) +} +void Request::set_allocated_unregister_client_buffer(::subspace::UnregisterClientBufferRequest* unregister_client_buffer) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (unregister_client_buffer) { + ::google::protobuf::Arena* submessage_arena = unregister_client_buffer->GetArena(); + if (message_arena != submessage_arena) { + unregister_client_buffer = ::google::protobuf::internal::GetOwnedMessage(message_arena, unregister_client_buffer, submessage_arena); + } + set_has_unregister_client_buffer(); + _impl_.request_.unregister_client_buffer_ = unregister_client_buffer; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Request.unregister_client_buffer) +} +Request::Request(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Request) +} +inline PROTOBUF_NDEBUG_INLINE Request::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Request& from_msg) + : request_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +Request::Request( + ::google::protobuf::Arena* arena, + const Request& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Request* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + switch (request_case()) { + case REQUEST_NOT_SET: + break; + case kInit: + _impl_.request_.init_ = ::google::protobuf::Message::CopyConstruct<::subspace::InitRequest>(arena, *from._impl_.request_.init_); + break; + case kCreatePublisher: + _impl_.request_.create_publisher_ = ::google::protobuf::Message::CopyConstruct<::subspace::CreatePublisherRequest>(arena, *from._impl_.request_.create_publisher_); + break; + case kCreateSubscriber: + _impl_.request_.create_subscriber_ = ::google::protobuf::Message::CopyConstruct<::subspace::CreateSubscriberRequest>(arena, *from._impl_.request_.create_subscriber_); + break; + case kGetTriggers: + _impl_.request_.get_triggers_ = ::google::protobuf::Message::CopyConstruct<::subspace::GetTriggersRequest>(arena, *from._impl_.request_.get_triggers_); + break; + case kRemovePublisher: + _impl_.request_.remove_publisher_ = ::google::protobuf::Message::CopyConstruct<::subspace::RemovePublisherRequest>(arena, *from._impl_.request_.remove_publisher_); + break; + case kRemoveSubscriber: + _impl_.request_.remove_subscriber_ = ::google::protobuf::Message::CopyConstruct<::subspace::RemoveSubscriberRequest>(arena, *from._impl_.request_.remove_subscriber_); + break; + case kGetChannelInfo: + _impl_.request_.get_channel_info_ = ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelInfoRequest>(arena, *from._impl_.request_.get_channel_info_); + break; + case kGetChannelStats: + _impl_.request_.get_channel_stats_ = ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelStatsRequest>(arena, *from._impl_.request_.get_channel_stats_); + break; + case kRegisterClientBuffer: + _impl_.request_.register_client_buffer_ = ::google::protobuf::Message::CopyConstruct<::subspace::RegisterClientBufferRequest>(arena, *from._impl_.request_.register_client_buffer_); + break; + case kUnregisterClientBuffer: + _impl_.request_.unregister_client_buffer_ = ::google::protobuf::Message::CopyConstruct<::subspace::UnregisterClientBufferRequest>(arena, *from._impl_.request_.unregister_client_buffer_); + break; + } + + // @@protoc_insertion_point(copy_constructor:subspace.Request) +} +inline PROTOBUF_NDEBUG_INLINE Request::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : request_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void Request::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +Request::~Request() { + // @@protoc_insertion_point(destructor:subspace.Request) + SharedDtor(*this); +} +inline void Request::SharedDtor(MessageLite& self) { + Request& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + if (this_.has_request()) { + this_.clear_request(); + } + this_._impl_.~Impl_(); +} + +void Request::clear_request() { +// @@protoc_insertion_point(one_of_clear_start:subspace.Request) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (request_case()) { + case kInit: { + if (GetArena() == nullptr) { + delete _impl_.request_.init_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.init_); + } + break; + } + case kCreatePublisher: { + if (GetArena() == nullptr) { + delete _impl_.request_.create_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.create_publisher_); + } + break; + } + case kCreateSubscriber: { + if (GetArena() == nullptr) { + delete _impl_.request_.create_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.create_subscriber_); + } + break; + } + case kGetTriggers: { + if (GetArena() == nullptr) { + delete _impl_.request_.get_triggers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.get_triggers_); + } + break; + } + case kRemovePublisher: { + if (GetArena() == nullptr) { + delete _impl_.request_.remove_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.remove_publisher_); + } + break; + } + case kRemoveSubscriber: { + if (GetArena() == nullptr) { + delete _impl_.request_.remove_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.remove_subscriber_); + } + break; + } + case kGetChannelInfo: { + if (GetArena() == nullptr) { + delete _impl_.request_.get_channel_info_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.get_channel_info_); + } + break; + } + case kGetChannelStats: { + if (GetArena() == nullptr) { + delete _impl_.request_.get_channel_stats_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.get_channel_stats_); + } + break; + } + case kRegisterClientBuffer: { + if (GetArena() == nullptr) { + delete _impl_.request_.register_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.register_client_buffer_); + } + break; + } + case kUnregisterClientBuffer: { + if (GetArena() == nullptr) { + delete _impl_.request_.unregister_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.unregister_client_buffer_); + } + break; + } + case REQUEST_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = REQUEST_NOT_SET; +} + + +inline void* Request::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Request(arena); +} +constexpr auto Request::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Request), + alignof(Request)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Request::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Request_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Request::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Request::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Request::ByteSizeLong, + &Request::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Request, _impl_._cached_size_), + false, + }, + &Request::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Request::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 10, 10, 0, 2> Request::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 12, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294963392, // skipmap + offsetof(decltype(_table_), field_entries), + 10, // num_field_entries + 10, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Request>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .subspace.InitRequest init = 1; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.init_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.CreatePublisherRequest create_publisher = 2; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.create_publisher_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.CreateSubscriberRequest create_subscriber = 3; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.create_subscriber_), _Internal::kOneofCaseOffset + 0, 2, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.GetTriggersRequest get_triggers = 4; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.get_triggers_), _Internal::kOneofCaseOffset + 0, 3, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RemovePublisherRequest remove_publisher = 5; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.remove_publisher_), _Internal::kOneofCaseOffset + 0, 4, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RemoveSubscriberRequest remove_subscriber = 6; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.remove_subscriber_), _Internal::kOneofCaseOffset + 0, 5, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.GetChannelInfoRequest get_channel_info = 9; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.get_channel_info_), _Internal::kOneofCaseOffset + 0, 6, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.GetChannelStatsRequest get_channel_stats = 10; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.get_channel_stats_), _Internal::kOneofCaseOffset + 0, 7, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RegisterClientBufferRequest register_client_buffer = 11; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.register_client_buffer_), _Internal::kOneofCaseOffset + 0, 8, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.UnregisterClientBufferRequest unregister_client_buffer = 12; + {PROTOBUF_FIELD_OFFSET(Request, _impl_.request_.unregister_client_buffer_), _Internal::kOneofCaseOffset + 0, 9, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::InitRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::CreatePublisherRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::CreateSubscriberRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::GetTriggersRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::RemovePublisherRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::RemoveSubscriberRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::GetChannelInfoRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::GetChannelStatsRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::RegisterClientBufferRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::UnregisterClientBufferRequest>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void Request::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Request) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_request(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Request::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Request& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Request::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Request& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Request) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (this_.request_case()) { + case kInit: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.request_.init_, this_._impl_.request_.init_->GetCachedSize(), target, + stream); + break; + } + case kCreatePublisher: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.request_.create_publisher_, this_._impl_.request_.create_publisher_->GetCachedSize(), target, + stream); + break; + } + case kCreateSubscriber: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.request_.create_subscriber_, this_._impl_.request_.create_subscriber_->GetCachedSize(), target, + stream); + break; + } + case kGetTriggers: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.request_.get_triggers_, this_._impl_.request_.get_triggers_->GetCachedSize(), target, + stream); + break; + } + case kRemovePublisher: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 5, *this_._impl_.request_.remove_publisher_, this_._impl_.request_.remove_publisher_->GetCachedSize(), target, + stream); + break; + } + case kRemoveSubscriber: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 6, *this_._impl_.request_.remove_subscriber_, this_._impl_.request_.remove_subscriber_->GetCachedSize(), target, + stream); + break; + } + case kGetChannelInfo: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 9, *this_._impl_.request_.get_channel_info_, this_._impl_.request_.get_channel_info_->GetCachedSize(), target, + stream); + break; + } + case kGetChannelStats: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 10, *this_._impl_.request_.get_channel_stats_, this_._impl_.request_.get_channel_stats_->GetCachedSize(), target, + stream); + break; + } + case kRegisterClientBuffer: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 11, *this_._impl_.request_.register_client_buffer_, this_._impl_.request_.register_client_buffer_->GetCachedSize(), target, + stream); + break; + } + case kUnregisterClientBuffer: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 12, *this_._impl_.request_.unregister_client_buffer_, this_._impl_.request_.unregister_client_buffer_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Request) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Request::ByteSizeLong(const MessageLite& base) { + const Request& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Request::ByteSizeLong() const { + const Request& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Request) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (this_.request_case()) { + // .subspace.InitRequest init = 1; + case kInit: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.init_); + break; + } + // .subspace.CreatePublisherRequest create_publisher = 2; + case kCreatePublisher: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.create_publisher_); + break; + } + // .subspace.CreateSubscriberRequest create_subscriber = 3; + case kCreateSubscriber: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.create_subscriber_); + break; + } + // .subspace.GetTriggersRequest get_triggers = 4; + case kGetTriggers: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.get_triggers_); + break; + } + // .subspace.RemovePublisherRequest remove_publisher = 5; + case kRemovePublisher: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.remove_publisher_); + break; + } + // .subspace.RemoveSubscriberRequest remove_subscriber = 6; + case kRemoveSubscriber: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.remove_subscriber_); + break; + } + // .subspace.GetChannelInfoRequest get_channel_info = 9; + case kGetChannelInfo: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.get_channel_info_); + break; + } + // .subspace.GetChannelStatsRequest get_channel_stats = 10; + case kGetChannelStats: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.get_channel_stats_); + break; + } + // .subspace.RegisterClientBufferRequest register_client_buffer = 11; + case kRegisterClientBuffer: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.register_client_buffer_); + break; + } + // .subspace.UnregisterClientBufferRequest unregister_client_buffer = 12; + case kUnregisterClientBuffer: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.unregister_client_buffer_); + break; + } + case REQUEST_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Request::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Request) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_request(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kInit: { + if (oneof_needs_init) { + _this->_impl_.request_.init_ = + ::google::protobuf::Message::CopyConstruct<::subspace::InitRequest>(arena, *from._impl_.request_.init_); + } else { + _this->_impl_.request_.init_->MergeFrom(from._internal_init()); + } + break; + } + case kCreatePublisher: { + if (oneof_needs_init) { + _this->_impl_.request_.create_publisher_ = + ::google::protobuf::Message::CopyConstruct<::subspace::CreatePublisherRequest>(arena, *from._impl_.request_.create_publisher_); + } else { + _this->_impl_.request_.create_publisher_->MergeFrom(from._internal_create_publisher()); + } + break; + } + case kCreateSubscriber: { + if (oneof_needs_init) { + _this->_impl_.request_.create_subscriber_ = + ::google::protobuf::Message::CopyConstruct<::subspace::CreateSubscriberRequest>(arena, *from._impl_.request_.create_subscriber_); + } else { + _this->_impl_.request_.create_subscriber_->MergeFrom(from._internal_create_subscriber()); + } + break; + } + case kGetTriggers: { + if (oneof_needs_init) { + _this->_impl_.request_.get_triggers_ = + ::google::protobuf::Message::CopyConstruct<::subspace::GetTriggersRequest>(arena, *from._impl_.request_.get_triggers_); + } else { + _this->_impl_.request_.get_triggers_->MergeFrom(from._internal_get_triggers()); + } + break; + } + case kRemovePublisher: { + if (oneof_needs_init) { + _this->_impl_.request_.remove_publisher_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RemovePublisherRequest>(arena, *from._impl_.request_.remove_publisher_); + } else { + _this->_impl_.request_.remove_publisher_->MergeFrom(from._internal_remove_publisher()); + } + break; + } + case kRemoveSubscriber: { + if (oneof_needs_init) { + _this->_impl_.request_.remove_subscriber_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RemoveSubscriberRequest>(arena, *from._impl_.request_.remove_subscriber_); + } else { + _this->_impl_.request_.remove_subscriber_->MergeFrom(from._internal_remove_subscriber()); + } + break; + } + case kGetChannelInfo: { + if (oneof_needs_init) { + _this->_impl_.request_.get_channel_info_ = + ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelInfoRequest>(arena, *from._impl_.request_.get_channel_info_); + } else { + _this->_impl_.request_.get_channel_info_->MergeFrom(from._internal_get_channel_info()); + } + break; + } + case kGetChannelStats: { + if (oneof_needs_init) { + _this->_impl_.request_.get_channel_stats_ = + ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelStatsRequest>(arena, *from._impl_.request_.get_channel_stats_); + } else { + _this->_impl_.request_.get_channel_stats_->MergeFrom(from._internal_get_channel_stats()); + } + break; + } + case kRegisterClientBuffer: { + if (oneof_needs_init) { + _this->_impl_.request_.register_client_buffer_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RegisterClientBufferRequest>(arena, *from._impl_.request_.register_client_buffer_); + } else { + _this->_impl_.request_.register_client_buffer_->MergeFrom(from._internal_register_client_buffer()); + } + break; + } + case kUnregisterClientBuffer: { + if (oneof_needs_init) { + _this->_impl_.request_.unregister_client_buffer_ = + ::google::protobuf::Message::CopyConstruct<::subspace::UnregisterClientBufferRequest>(arena, *from._impl_.request_.unregister_client_buffer_); + } else { + _this->_impl_.request_.unregister_client_buffer_->MergeFrom(from._internal_unregister_client_buffer()); + } + break; + } + case REQUEST_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Request::CopyFrom(const Request& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Request) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Request::InternalSwap(Request* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.request_, other->_impl_.request_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::google::protobuf::Metadata Request::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Response::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::subspace::Response, _impl_._oneof_case_); +}; + +void Response::set_allocated_init(::subspace::InitResponse* init) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (init) { + ::google::protobuf::Arena* submessage_arena = init->GetArena(); + if (message_arena != submessage_arena) { + init = ::google::protobuf::internal::GetOwnedMessage(message_arena, init, submessage_arena); + } + set_has_init(); + _impl_.response_.init_ = init; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.init) +} +void Response::set_allocated_create_publisher(::subspace::CreatePublisherResponse* create_publisher) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (create_publisher) { + ::google::protobuf::Arena* submessage_arena = create_publisher->GetArena(); + if (message_arena != submessage_arena) { + create_publisher = ::google::protobuf::internal::GetOwnedMessage(message_arena, create_publisher, submessage_arena); + } + set_has_create_publisher(); + _impl_.response_.create_publisher_ = create_publisher; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.create_publisher) +} +void Response::set_allocated_create_subscriber(::subspace::CreateSubscriberResponse* create_subscriber) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (create_subscriber) { + ::google::protobuf::Arena* submessage_arena = create_subscriber->GetArena(); + if (message_arena != submessage_arena) { + create_subscriber = ::google::protobuf::internal::GetOwnedMessage(message_arena, create_subscriber, submessage_arena); + } + set_has_create_subscriber(); + _impl_.response_.create_subscriber_ = create_subscriber; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.create_subscriber) +} +void Response::set_allocated_get_triggers(::subspace::GetTriggersResponse* get_triggers) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (get_triggers) { + ::google::protobuf::Arena* submessage_arena = get_triggers->GetArena(); + if (message_arena != submessage_arena) { + get_triggers = ::google::protobuf::internal::GetOwnedMessage(message_arena, get_triggers, submessage_arena); + } + set_has_get_triggers(); + _impl_.response_.get_triggers_ = get_triggers; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.get_triggers) +} +void Response::set_allocated_remove_publisher(::subspace::RemovePublisherResponse* remove_publisher) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (remove_publisher) { + ::google::protobuf::Arena* submessage_arena = remove_publisher->GetArena(); + if (message_arena != submessage_arena) { + remove_publisher = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_publisher, submessage_arena); + } + set_has_remove_publisher(); + _impl_.response_.remove_publisher_ = remove_publisher; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.remove_publisher) +} +void Response::set_allocated_remove_subscriber(::subspace::RemoveSubscriberResponse* remove_subscriber) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (remove_subscriber) { + ::google::protobuf::Arena* submessage_arena = remove_subscriber->GetArena(); + if (message_arena != submessage_arena) { + remove_subscriber = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_subscriber, submessage_arena); + } + set_has_remove_subscriber(); + _impl_.response_.remove_subscriber_ = remove_subscriber; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.remove_subscriber) +} +void Response::set_allocated_get_channel_info(::subspace::GetChannelInfoResponse* get_channel_info) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (get_channel_info) { + ::google::protobuf::Arena* submessage_arena = get_channel_info->GetArena(); + if (message_arena != submessage_arena) { + get_channel_info = ::google::protobuf::internal::GetOwnedMessage(message_arena, get_channel_info, submessage_arena); + } + set_has_get_channel_info(); + _impl_.response_.get_channel_info_ = get_channel_info; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.get_channel_info) +} +void Response::set_allocated_get_channel_stats(::subspace::GetChannelStatsResponse* get_channel_stats) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (get_channel_stats) { + ::google::protobuf::Arena* submessage_arena = get_channel_stats->GetArena(); + if (message_arena != submessage_arena) { + get_channel_stats = ::google::protobuf::internal::GetOwnedMessage(message_arena, get_channel_stats, submessage_arena); + } + set_has_get_channel_stats(); + _impl_.response_.get_channel_stats_ = get_channel_stats; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Response.get_channel_stats) +} +Response::Response(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Response) +} +inline PROTOBUF_NDEBUG_INLINE Response::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Response& from_msg) + : response_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +Response::Response( + ::google::protobuf::Arena* arena, + const Response& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Response* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + switch (response_case()) { + case RESPONSE_NOT_SET: + break; + case kInit: + _impl_.response_.init_ = ::google::protobuf::Message::CopyConstruct<::subspace::InitResponse>(arena, *from._impl_.response_.init_); + break; + case kCreatePublisher: + _impl_.response_.create_publisher_ = ::google::protobuf::Message::CopyConstruct<::subspace::CreatePublisherResponse>(arena, *from._impl_.response_.create_publisher_); + break; + case kCreateSubscriber: + _impl_.response_.create_subscriber_ = ::google::protobuf::Message::CopyConstruct<::subspace::CreateSubscriberResponse>(arena, *from._impl_.response_.create_subscriber_); + break; + case kGetTriggers: + _impl_.response_.get_triggers_ = ::google::protobuf::Message::CopyConstruct<::subspace::GetTriggersResponse>(arena, *from._impl_.response_.get_triggers_); + break; + case kRemovePublisher: + _impl_.response_.remove_publisher_ = ::google::protobuf::Message::CopyConstruct<::subspace::RemovePublisherResponse>(arena, *from._impl_.response_.remove_publisher_); + break; + case kRemoveSubscriber: + _impl_.response_.remove_subscriber_ = ::google::protobuf::Message::CopyConstruct<::subspace::RemoveSubscriberResponse>(arena, *from._impl_.response_.remove_subscriber_); + break; + case kGetChannelInfo: + _impl_.response_.get_channel_info_ = ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelInfoResponse>(arena, *from._impl_.response_.get_channel_info_); + break; + case kGetChannelStats: + _impl_.response_.get_channel_stats_ = ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelStatsResponse>(arena, *from._impl_.response_.get_channel_stats_); + break; + } + + // @@protoc_insertion_point(copy_constructor:subspace.Response) +} +inline PROTOBUF_NDEBUG_INLINE Response::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : response_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void Response::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +Response::~Response() { + // @@protoc_insertion_point(destructor:subspace.Response) + SharedDtor(*this); +} +inline void Response::SharedDtor(MessageLite& self) { + Response& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + if (this_.has_response()) { + this_.clear_response(); + } + this_._impl_.~Impl_(); +} + +void Response::clear_response() { +// @@protoc_insertion_point(one_of_clear_start:subspace.Response) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (response_case()) { + case kInit: { + if (GetArena() == nullptr) { + delete _impl_.response_.init_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.init_); + } + break; + } + case kCreatePublisher: { + if (GetArena() == nullptr) { + delete _impl_.response_.create_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.create_publisher_); + } + break; + } + case kCreateSubscriber: { + if (GetArena() == nullptr) { + delete _impl_.response_.create_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.create_subscriber_); + } + break; + } + case kGetTriggers: { + if (GetArena() == nullptr) { + delete _impl_.response_.get_triggers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.get_triggers_); + } + break; + } + case kRemovePublisher: { + if (GetArena() == nullptr) { + delete _impl_.response_.remove_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.remove_publisher_); + } + break; + } + case kRemoveSubscriber: { + if (GetArena() == nullptr) { + delete _impl_.response_.remove_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.remove_subscriber_); + } + break; + } + case kGetChannelInfo: { + if (GetArena() == nullptr) { + delete _impl_.response_.get_channel_info_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.get_channel_info_); + } + break; + } + case kGetChannelStats: { + if (GetArena() == nullptr) { + delete _impl_.response_.get_channel_stats_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.get_channel_stats_); + } + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = RESPONSE_NOT_SET; +} + + +inline void* Response::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Response(arena); +} +constexpr auto Response::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Response), + alignof(Response)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Response::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Response_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Response::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Response::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Response::ByteSizeLong, + &Response::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Response, _impl_._cached_size_), + false, + }, + &Response::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Response::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 8, 8, 0, 2> Response::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 10, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966464, // skipmap + offsetof(decltype(_table_), field_entries), + 8, // num_field_entries + 8, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Response>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .subspace.InitResponse init = 1; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.init_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.CreatePublisherResponse create_publisher = 2; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.create_publisher_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.CreateSubscriberResponse create_subscriber = 3; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.create_subscriber_), _Internal::kOneofCaseOffset + 0, 2, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.GetTriggersResponse get_triggers = 4; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.get_triggers_), _Internal::kOneofCaseOffset + 0, 3, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RemovePublisherResponse remove_publisher = 5; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.remove_publisher_), _Internal::kOneofCaseOffset + 0, 4, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RemoveSubscriberResponse remove_subscriber = 6; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.remove_subscriber_), _Internal::kOneofCaseOffset + 0, 5, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.GetChannelInfoResponse get_channel_info = 9; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.get_channel_info_), _Internal::kOneofCaseOffset + 0, 6, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.GetChannelStatsResponse get_channel_stats = 10; + {PROTOBUF_FIELD_OFFSET(Response, _impl_.response_.get_channel_stats_), _Internal::kOneofCaseOffset + 0, 7, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::InitResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::CreatePublisherResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::CreateSubscriberResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::GetTriggersResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::RemovePublisherResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::RemoveSubscriberResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::GetChannelInfoResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::GetChannelStatsResponse>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void Response::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Response) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_response(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Response::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Response& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Response::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Response& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Response) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (this_.response_case()) { + case kInit: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.response_.init_, this_._impl_.response_.init_->GetCachedSize(), target, + stream); + break; + } + case kCreatePublisher: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.response_.create_publisher_, this_._impl_.response_.create_publisher_->GetCachedSize(), target, + stream); + break; + } + case kCreateSubscriber: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.response_.create_subscriber_, this_._impl_.response_.create_subscriber_->GetCachedSize(), target, + stream); + break; + } + case kGetTriggers: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.response_.get_triggers_, this_._impl_.response_.get_triggers_->GetCachedSize(), target, + stream); + break; + } + case kRemovePublisher: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 5, *this_._impl_.response_.remove_publisher_, this_._impl_.response_.remove_publisher_->GetCachedSize(), target, + stream); + break; + } + case kRemoveSubscriber: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 6, *this_._impl_.response_.remove_subscriber_, this_._impl_.response_.remove_subscriber_->GetCachedSize(), target, + stream); + break; + } + case kGetChannelInfo: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 9, *this_._impl_.response_.get_channel_info_, this_._impl_.response_.get_channel_info_->GetCachedSize(), target, + stream); + break; + } + case kGetChannelStats: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 10, *this_._impl_.response_.get_channel_stats_, this_._impl_.response_.get_channel_stats_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Response) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Response::ByteSizeLong(const MessageLite& base) { + const Response& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Response::ByteSizeLong() const { + const Response& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Response) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (this_.response_case()) { + // .subspace.InitResponse init = 1; + case kInit: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.init_); + break; + } + // .subspace.CreatePublisherResponse create_publisher = 2; + case kCreatePublisher: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.create_publisher_); + break; + } + // .subspace.CreateSubscriberResponse create_subscriber = 3; + case kCreateSubscriber: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.create_subscriber_); + break; + } + // .subspace.GetTriggersResponse get_triggers = 4; + case kGetTriggers: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.get_triggers_); + break; + } + // .subspace.RemovePublisherResponse remove_publisher = 5; + case kRemovePublisher: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.remove_publisher_); + break; + } + // .subspace.RemoveSubscriberResponse remove_subscriber = 6; + case kRemoveSubscriber: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.remove_subscriber_); + break; + } + // .subspace.GetChannelInfoResponse get_channel_info = 9; + case kGetChannelInfo: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.get_channel_info_); + break; + } + // .subspace.GetChannelStatsResponse get_channel_stats = 10; + case kGetChannelStats: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.get_channel_stats_); + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Response::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Response) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_response(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kInit: { + if (oneof_needs_init) { + _this->_impl_.response_.init_ = + ::google::protobuf::Message::CopyConstruct<::subspace::InitResponse>(arena, *from._impl_.response_.init_); + } else { + _this->_impl_.response_.init_->MergeFrom(from._internal_init()); + } + break; + } + case kCreatePublisher: { + if (oneof_needs_init) { + _this->_impl_.response_.create_publisher_ = + ::google::protobuf::Message::CopyConstruct<::subspace::CreatePublisherResponse>(arena, *from._impl_.response_.create_publisher_); + } else { + _this->_impl_.response_.create_publisher_->MergeFrom(from._internal_create_publisher()); + } + break; + } + case kCreateSubscriber: { + if (oneof_needs_init) { + _this->_impl_.response_.create_subscriber_ = + ::google::protobuf::Message::CopyConstruct<::subspace::CreateSubscriberResponse>(arena, *from._impl_.response_.create_subscriber_); + } else { + _this->_impl_.response_.create_subscriber_->MergeFrom(from._internal_create_subscriber()); + } + break; + } + case kGetTriggers: { + if (oneof_needs_init) { + _this->_impl_.response_.get_triggers_ = + ::google::protobuf::Message::CopyConstruct<::subspace::GetTriggersResponse>(arena, *from._impl_.response_.get_triggers_); + } else { + _this->_impl_.response_.get_triggers_->MergeFrom(from._internal_get_triggers()); + } + break; + } + case kRemovePublisher: { + if (oneof_needs_init) { + _this->_impl_.response_.remove_publisher_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RemovePublisherResponse>(arena, *from._impl_.response_.remove_publisher_); + } else { + _this->_impl_.response_.remove_publisher_->MergeFrom(from._internal_remove_publisher()); + } + break; + } + case kRemoveSubscriber: { + if (oneof_needs_init) { + _this->_impl_.response_.remove_subscriber_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RemoveSubscriberResponse>(arena, *from._impl_.response_.remove_subscriber_); + } else { + _this->_impl_.response_.remove_subscriber_->MergeFrom(from._internal_remove_subscriber()); + } + break; + } + case kGetChannelInfo: { + if (oneof_needs_init) { + _this->_impl_.response_.get_channel_info_ = + ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelInfoResponse>(arena, *from._impl_.response_.get_channel_info_); + } else { + _this->_impl_.response_.get_channel_info_->MergeFrom(from._internal_get_channel_info()); + } + break; + } + case kGetChannelStats: { + if (oneof_needs_init) { + _this->_impl_.response_.get_channel_stats_ = + ::google::protobuf::Message::CopyConstruct<::subspace::GetChannelStatsResponse>(arena, *from._impl_.response_.get_channel_stats_); + } else { + _this->_impl_.response_.get_channel_stats_->MergeFrom(from._internal_get_channel_stats()); + } + break; + } + case RESPONSE_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Response::CopyFrom(const Response& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Response) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Response::InternalSwap(Response* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.response_, other->_impl_.response_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::google::protobuf::Metadata Response::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ChannelInfoProto::_Internal { + public: +}; + +ChannelInfoProto::ChannelInfoProto(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ChannelInfoProto) +} +inline PROTOBUF_NDEBUG_INLINE ChannelInfoProto::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ChannelInfoProto& from_msg) + : name_(arena, from.name_), + type_(arena, from.type_), + mux_(arena, from.mux_), + _cached_size_{0} {} + +ChannelInfoProto::ChannelInfoProto( + ::google::protobuf::Arena* arena, + const ChannelInfoProto& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ChannelInfoProto* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, slot_size_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, slot_size_), + offsetof(Impl_, num_tunnel_subs_) - + offsetof(Impl_, slot_size_) + + sizeof(Impl_::num_tunnel_subs_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ChannelInfoProto) +} +inline PROTOBUF_NDEBUG_INLINE ChannelInfoProto::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : name_(arena), + type_(arena), + mux_(arena), + _cached_size_{0} {} + +inline void ChannelInfoProto::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, slot_size_), + 0, + offsetof(Impl_, num_tunnel_subs_) - + offsetof(Impl_, slot_size_) + + sizeof(Impl_::num_tunnel_subs_)); +} +ChannelInfoProto::~ChannelInfoProto() { + // @@protoc_insertion_point(destructor:subspace.ChannelInfoProto) + SharedDtor(*this); +} +inline void ChannelInfoProto::SharedDtor(MessageLite& self) { + ChannelInfoProto& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.name_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.mux_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ChannelInfoProto::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ChannelInfoProto(arena); +} +constexpr auto ChannelInfoProto::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ChannelInfoProto), + alignof(ChannelInfoProto)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ChannelInfoProto::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ChannelInfoProto_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ChannelInfoProto::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ChannelInfoProto::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ChannelInfoProto::ByteSizeLong, + &ChannelInfoProto::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_._cached_size_), + false, + }, + &ChannelInfoProto::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ChannelInfoProto::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 14, 0, 49, 2> ChannelInfoProto::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 14, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294950912, // skipmap + offsetof(decltype(_table_), field_entries), + 14, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ChannelInfoProto>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.name_)}}, + // int32 slot_size = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.slot_size_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.slot_size_)}}, + // int32 num_slots = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_slots_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_slots_)}}, + // bytes type = 4; + {::_pbi::TcParser::FastBS1, + {34, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.type_)}}, + // int32 num_pubs = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_pubs_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_pubs_)}}, + // int32 num_subs = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_subs_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_subs_)}}, + // int32 num_bridge_pubs = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_bridge_pubs_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_bridge_pubs_)}}, + // int32 num_bridge_subs = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_bridge_subs_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_bridge_subs_)}}, + // bool is_reliable = 9; + {::_pbi::TcParser::SingularVarintNoZag1(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.is_reliable_)}}, + // bool is_virtual = 10; + {::_pbi::TcParser::SingularVarintNoZag1(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.is_virtual_)}}, + // int32 vchan_id = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.vchan_id_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.vchan_id_)}}, + // string mux = 12; + {::_pbi::TcParser::FastUS1, + {98, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.mux_)}}, + // int32 num_tunnel_pubs = 13; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_tunnel_pubs_), 63>(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_tunnel_pubs_)}}, + // int32 num_tunnel_subs = 14; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelInfoProto, _impl_.num_tunnel_subs_), 63>(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_tunnel_subs_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string name = 1; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 slot_size = 2; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.slot_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_slots = 3; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_slots_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes type = 4; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // int32 num_pubs = 5; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_pubs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_subs = 6; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_subs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_bridge_pubs = 7; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_bridge_pubs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_bridge_subs = 8; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_bridge_subs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool is_reliable = 9; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.is_reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_virtual = 10; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.is_virtual_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 vchan_id = 11; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.vchan_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // string mux = 12; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.mux_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 num_tunnel_pubs = 13; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_tunnel_pubs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_tunnel_subs = 14; + {PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_tunnel_subs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\31\4\0\0\0\0\0\0\0\0\0\0\3\0\0\0" + "subspace.ChannelInfoProto" + "name" + "mux" + }}, +}; + +PROTOBUF_NOINLINE void ChannelInfoProto::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ChannelInfoProto) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.name_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + _impl_.mux_.ClearToEmpty(); + ::memset(&_impl_.slot_size_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.num_tunnel_subs_) - + reinterpret_cast(&_impl_.slot_size_)) + sizeof(_impl_.num_tunnel_subs_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ChannelInfoProto::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ChannelInfoProto& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ChannelInfoProto::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ChannelInfoProto& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ChannelInfoProto) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string name = 1; + if (!this_._internal_name().empty()) { + const std::string& _s = this_._internal_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ChannelInfoProto.name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 slot_size = 2; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_slot_size(), target); + } + + // int32 num_slots = 3; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_num_slots(), target); + } + + // bytes type = 4; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + target = stream->WriteBytesMaybeAliased(4, _s, target); + } + + // int32 num_pubs = 5; + if (this_._internal_num_pubs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this_._internal_num_pubs(), target); + } + + // int32 num_subs = 6; + if (this_._internal_num_subs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this_._internal_num_subs(), target); + } + + // int32 num_bridge_pubs = 7; + if (this_._internal_num_bridge_pubs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this_._internal_num_bridge_pubs(), target); + } + + // int32 num_bridge_subs = 8; + if (this_._internal_num_bridge_subs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<8>( + stream, this_._internal_num_bridge_subs(), target); + } + + // bool is_reliable = 9; + if (this_._internal_is_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 9, this_._internal_is_reliable(), target); + } + + // bool is_virtual = 10; + if (this_._internal_is_virtual() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 10, this_._internal_is_virtual(), target); + } + + // int32 vchan_id = 11; + if (this_._internal_vchan_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<11>( + stream, this_._internal_vchan_id(), target); + } + + // string mux = 12; + if (!this_._internal_mux().empty()) { + const std::string& _s = this_._internal_mux(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ChannelInfoProto.mux"); + target = stream->WriteStringMaybeAliased(12, _s, target); + } + + // int32 num_tunnel_pubs = 13; + if (this_._internal_num_tunnel_pubs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<13>( + stream, this_._internal_num_tunnel_pubs(), target); + } + + // int32 num_tunnel_subs = 14; + if (this_._internal_num_tunnel_subs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<14>( + stream, this_._internal_num_tunnel_subs(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ChannelInfoProto) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ChannelInfoProto::ByteSizeLong(const MessageLite& base) { + const ChannelInfoProto& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ChannelInfoProto::ByteSizeLong() const { + const ChannelInfoProto& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ChannelInfoProto) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string name = 1; + if (!this_._internal_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_name()); + } + // bytes type = 4; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_type()); + } + // string mux = 12; + if (!this_._internal_mux().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_mux()); + } + // int32 slot_size = 2; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // int32 num_slots = 3; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + // int32 num_pubs = 5; + if (this_._internal_num_pubs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_pubs()); + } + // int32 num_subs = 6; + if (this_._internal_num_subs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_subs()); + } + // int32 num_bridge_pubs = 7; + if (this_._internal_num_bridge_pubs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_bridge_pubs()); + } + // int32 num_bridge_subs = 8; + if (this_._internal_num_bridge_subs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_bridge_subs()); + } + // bool is_reliable = 9; + if (this_._internal_is_reliable() != 0) { + total_size += 2; + } + // bool is_virtual = 10; + if (this_._internal_is_virtual() != 0) { + total_size += 2; + } + // int32 vchan_id = 11; + if (this_._internal_vchan_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_vchan_id()); + } + // int32 num_tunnel_pubs = 13; + if (this_._internal_num_tunnel_pubs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_tunnel_pubs()); + } + // int32 num_tunnel_subs = 14; + if (this_._internal_num_tunnel_subs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_tunnel_subs()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ChannelInfoProto::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ChannelInfoProto) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _this->_internal_set_name(from._internal_name()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (!from._internal_mux().empty()) { + _this->_internal_set_mux(from._internal_mux()); + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + if (from._internal_num_pubs() != 0) { + _this->_impl_.num_pubs_ = from._impl_.num_pubs_; + } + if (from._internal_num_subs() != 0) { + _this->_impl_.num_subs_ = from._impl_.num_subs_; + } + if (from._internal_num_bridge_pubs() != 0) { + _this->_impl_.num_bridge_pubs_ = from._impl_.num_bridge_pubs_; + } + if (from._internal_num_bridge_subs() != 0) { + _this->_impl_.num_bridge_subs_ = from._impl_.num_bridge_subs_; + } + if (from._internal_is_reliable() != 0) { + _this->_impl_.is_reliable_ = from._impl_.is_reliable_; + } + if (from._internal_is_virtual() != 0) { + _this->_impl_.is_virtual_ = from._impl_.is_virtual_; + } + if (from._internal_vchan_id() != 0) { + _this->_impl_.vchan_id_ = from._impl_.vchan_id_; + } + if (from._internal_num_tunnel_pubs() != 0) { + _this->_impl_.num_tunnel_pubs_ = from._impl_.num_tunnel_pubs_; + } + if (from._internal_num_tunnel_subs() != 0) { + _this->_impl_.num_tunnel_subs_ = from._impl_.num_tunnel_subs_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ChannelInfoProto::CopyFrom(const ChannelInfoProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ChannelInfoProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ChannelInfoProto::InternalSwap(ChannelInfoProto* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.mux_, &other->_impl_.mux_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.num_tunnel_subs_) + + sizeof(ChannelInfoProto::_impl_.num_tunnel_subs_) + - PROTOBUF_FIELD_OFFSET(ChannelInfoProto, _impl_.slot_size_)>( + reinterpret_cast(&_impl_.slot_size_), + reinterpret_cast(&other->_impl_.slot_size_)); +} + +::google::protobuf::Metadata ChannelInfoProto::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ChannelDirectory::_Internal { + public: +}; + +ChannelDirectory::ChannelDirectory(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ChannelDirectory) +} +inline PROTOBUF_NDEBUG_INLINE ChannelDirectory::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ChannelDirectory& from_msg) + : channels_{visibility, arena, from.channels_}, + server_id_(arena, from.server_id_), + _cached_size_{0} {} + +ChannelDirectory::ChannelDirectory( + ::google::protobuf::Arena* arena, + const ChannelDirectory& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ChannelDirectory* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.ChannelDirectory) +} +inline PROTOBUF_NDEBUG_INLINE ChannelDirectory::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channels_{visibility, arena}, + server_id_(arena), + _cached_size_{0} {} + +inline void ChannelDirectory::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ChannelDirectory::~ChannelDirectory() { + // @@protoc_insertion_point(destructor:subspace.ChannelDirectory) + SharedDtor(*this); +} +inline void ChannelDirectory::SharedDtor(MessageLite& self) { + ChannelDirectory& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.server_id_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ChannelDirectory::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ChannelDirectory(arena); +} +constexpr auto ChannelDirectory::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ChannelDirectory, _impl_.channels_) + + decltype(ChannelDirectory::_impl_.channels_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(ChannelDirectory), alignof(ChannelDirectory), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ChannelDirectory::PlacementNew_, + sizeof(ChannelDirectory), + alignof(ChannelDirectory)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ChannelDirectory::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ChannelDirectory_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ChannelDirectory::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ChannelDirectory::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ChannelDirectory::ByteSizeLong, + &ChannelDirectory::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ChannelDirectory, _impl_._cached_size_), + false, + }, + &ChannelDirectory::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ChannelDirectory::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 43, 2> ChannelDirectory::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ChannelDirectory>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .subspace.ChannelInfoProto channels = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelDirectory, _impl_.channels_)}}, + // string server_id = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelDirectory, _impl_.server_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string server_id = 1; + {PROTOBUF_FIELD_OFFSET(ChannelDirectory, _impl_.server_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // repeated .subspace.ChannelInfoProto channels = 2; + {PROTOBUF_FIELD_OFFSET(ChannelDirectory, _impl_.channels_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ChannelInfoProto>()}, + }}, {{ + "\31\11\0\0\0\0\0\0" + "subspace.ChannelDirectory" + "server_id" + }}, +}; + +PROTOBUF_NOINLINE void ChannelDirectory::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ChannelDirectory) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channels_.Clear(); + _impl_.server_id_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ChannelDirectory::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ChannelDirectory& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ChannelDirectory::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ChannelDirectory& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ChannelDirectory) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string server_id = 1; + if (!this_._internal_server_id().empty()) { + const std::string& _s = this_._internal_server_id(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ChannelDirectory.server_id"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // repeated .subspace.ChannelInfoProto channels = 2; + for (unsigned i = 0, n = static_cast( + this_._internal_channels_size()); + i < n; i++) { + const auto& repfield = this_._internal_channels().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ChannelDirectory) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ChannelDirectory::ByteSizeLong(const MessageLite& base) { + const ChannelDirectory& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ChannelDirectory::ByteSizeLong() const { + const ChannelDirectory& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ChannelDirectory) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .subspace.ChannelInfoProto channels = 2; + { + total_size += 1UL * this_._internal_channels_size(); + for (const auto& msg : this_._internal_channels()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + { + // string server_id = 1; + if (!this_._internal_server_id().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_server_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ChannelDirectory::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ChannelDirectory) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_channels()->MergeFrom( + from._internal_channels()); + if (!from._internal_server_id().empty()) { + _this->_internal_set_server_id(from._internal_server_id()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ChannelDirectory::CopyFrom(const ChannelDirectory& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ChannelDirectory) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ChannelDirectory::InternalSwap(ChannelDirectory* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.channels_.InternalSwap(&other->_impl_.channels_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.server_id_, &other->_impl_.server_id_, arena); +} + +::google::protobuf::Metadata ChannelDirectory::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ChannelStatsProto::_Internal { + public: +}; + +ChannelStatsProto::ChannelStatsProto(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ChannelStatsProto) +} +inline PROTOBUF_NDEBUG_INLINE ChannelStatsProto::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ChannelStatsProto& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ChannelStatsProto::ChannelStatsProto( + ::google::protobuf::Arena* arena, + const ChannelStatsProto& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ChannelStatsProto* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, total_bytes_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, total_bytes_), + offsetof(Impl_, num_bridge_subs_) - + offsetof(Impl_, total_bytes_) + + sizeof(Impl_::num_bridge_subs_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ChannelStatsProto) +} +inline PROTOBUF_NDEBUG_INLINE ChannelStatsProto::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ChannelStatsProto::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, total_bytes_), + 0, + offsetof(Impl_, num_bridge_subs_) - + offsetof(Impl_, total_bytes_) + + sizeof(Impl_::num_bridge_subs_)); +} +ChannelStatsProto::~ChannelStatsProto() { + // @@protoc_insertion_point(destructor:subspace.ChannelStatsProto) + SharedDtor(*this); +} +inline void ChannelStatsProto::SharedDtor(MessageLite& self) { + ChannelStatsProto& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ChannelStatsProto::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ChannelStatsProto(arena); +} +constexpr auto ChannelStatsProto::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ChannelStatsProto), + alignof(ChannelStatsProto)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ChannelStatsProto::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ChannelStatsProto_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ChannelStatsProto::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ChannelStatsProto::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ChannelStatsProto::ByteSizeLong, + &ChannelStatsProto::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_._cached_size_), + false, + }, + &ChannelStatsProto::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ChannelStatsProto::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 11, 0, 55, 2> ChannelStatsProto::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 11, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294965248, // skipmap + offsetof(decltype(_table_), field_entries), + 11, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ChannelStatsProto>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.channel_name_)}}, + // int64 total_bytes = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ChannelStatsProto, _impl_.total_bytes_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_bytes_)}}, + // int64 total_messages = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ChannelStatsProto, _impl_.total_messages_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_messages_)}}, + // int32 slot_size = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.slot_size_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.slot_size_)}}, + // int32 num_slots = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.num_slots_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_slots_)}}, + // int32 num_pubs = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.num_pubs_), 63>(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_pubs_)}}, + // int32 num_subs = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.num_subs_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_subs_)}}, + // uint32 max_message_size = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.max_message_size_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.max_message_size_)}}, + // uint32 total_drops = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.total_drops_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_drops_)}}, + // int32 num_bridge_pubs = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.num_bridge_pubs_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_bridge_pubs_)}}, + // int32 num_bridge_subs = 11; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelStatsProto, _impl_.num_bridge_subs_), 63>(), + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_bridge_subs_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int64 total_bytes = 2; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_bytes_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int64 total_messages = 3; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_messages_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // int32 slot_size = 4; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.slot_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_slots = 5; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_slots_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_pubs = 6; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_pubs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_subs = 7; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_subs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint32 max_message_size = 8; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.max_message_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 total_drops = 9; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_drops_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // int32 num_bridge_pubs = 10; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_bridge_pubs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_bridge_subs = 11; + {PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_bridge_subs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\32\14\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.ChannelStatsProto" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ChannelStatsProto::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ChannelStatsProto) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.total_bytes_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.num_bridge_subs_) - + reinterpret_cast(&_impl_.total_bytes_)) + sizeof(_impl_.num_bridge_subs_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ChannelStatsProto::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ChannelStatsProto& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ChannelStatsProto::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ChannelStatsProto& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ChannelStatsProto) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ChannelStatsProto.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int64 total_bytes = 2; + if (this_._internal_total_bytes() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<2>( + stream, this_._internal_total_bytes(), target); + } + + // int64 total_messages = 3; + if (this_._internal_total_messages() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<3>( + stream, this_._internal_total_messages(), target); + } + + // int32 slot_size = 4; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_slot_size(), target); + } + + // int32 num_slots = 5; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this_._internal_num_slots(), target); + } + + // int32 num_pubs = 6; + if (this_._internal_num_pubs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<6>( + stream, this_._internal_num_pubs(), target); + } + + // int32 num_subs = 7; + if (this_._internal_num_subs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this_._internal_num_subs(), target); + } + + // uint32 max_message_size = 8; + if (this_._internal_max_message_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this_._internal_max_message_size(), target); + } + + // uint32 total_drops = 9; + if (this_._internal_total_drops() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this_._internal_total_drops(), target); + } + + // int32 num_bridge_pubs = 10; + if (this_._internal_num_bridge_pubs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<10>( + stream, this_._internal_num_bridge_pubs(), target); + } + + // int32 num_bridge_subs = 11; + if (this_._internal_num_bridge_subs() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<11>( + stream, this_._internal_num_bridge_subs(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ChannelStatsProto) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ChannelStatsProto::ByteSizeLong(const MessageLite& base) { + const ChannelStatsProto& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ChannelStatsProto::ByteSizeLong() const { + const ChannelStatsProto& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ChannelStatsProto) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int64 total_bytes = 2; + if (this_._internal_total_bytes() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_total_bytes()); + } + // int64 total_messages = 3; + if (this_._internal_total_messages() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_total_messages()); + } + // int32 slot_size = 4; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // int32 num_slots = 5; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + // int32 num_pubs = 6; + if (this_._internal_num_pubs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_pubs()); + } + // int32 num_subs = 7; + if (this_._internal_num_subs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_subs()); + } + // uint32 max_message_size = 8; + if (this_._internal_max_message_size() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_max_message_size()); + } + // uint32 total_drops = 9; + if (this_._internal_total_drops() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_total_drops()); + } + // int32 num_bridge_pubs = 10; + if (this_._internal_num_bridge_pubs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_bridge_pubs()); + } + // int32 num_bridge_subs = 11; + if (this_._internal_num_bridge_subs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_bridge_subs()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ChannelStatsProto::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ChannelStatsProto) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_total_bytes() != 0) { + _this->_impl_.total_bytes_ = from._impl_.total_bytes_; + } + if (from._internal_total_messages() != 0) { + _this->_impl_.total_messages_ = from._impl_.total_messages_; + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + if (from._internal_num_pubs() != 0) { + _this->_impl_.num_pubs_ = from._impl_.num_pubs_; + } + if (from._internal_num_subs() != 0) { + _this->_impl_.num_subs_ = from._impl_.num_subs_; + } + if (from._internal_max_message_size() != 0) { + _this->_impl_.max_message_size_ = from._impl_.max_message_size_; + } + if (from._internal_total_drops() != 0) { + _this->_impl_.total_drops_ = from._impl_.total_drops_; + } + if (from._internal_num_bridge_pubs() != 0) { + _this->_impl_.num_bridge_pubs_ = from._impl_.num_bridge_pubs_; + } + if (from._internal_num_bridge_subs() != 0) { + _this->_impl_.num_bridge_subs_ = from._impl_.num_bridge_subs_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ChannelStatsProto::CopyFrom(const ChannelStatsProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ChannelStatsProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ChannelStatsProto::InternalSwap(ChannelStatsProto* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.num_bridge_subs_) + + sizeof(ChannelStatsProto::_impl_.num_bridge_subs_) + - PROTOBUF_FIELD_OFFSET(ChannelStatsProto, _impl_.total_bytes_)>( + reinterpret_cast(&_impl_.total_bytes_), + reinterpret_cast(&other->_impl_.total_bytes_)); +} + +::google::protobuf::Metadata ChannelStatsProto::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Statistics::_Internal { + public: +}; + +Statistics::Statistics(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Statistics) +} +inline PROTOBUF_NDEBUG_INLINE Statistics::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Statistics& from_msg) + : channels_{visibility, arena, from.channels_}, + server_id_(arena, from.server_id_), + _cached_size_{0} {} + +Statistics::Statistics( + ::google::protobuf::Arena* arena, + const Statistics& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Statistics* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.timestamp_ = from._impl_.timestamp_; + + // @@protoc_insertion_point(copy_constructor:subspace.Statistics) +} +inline PROTOBUF_NDEBUG_INLINE Statistics::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channels_{visibility, arena}, + server_id_(arena), + _cached_size_{0} {} + +inline void Statistics::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.timestamp_ = {}; +} +Statistics::~Statistics() { + // @@protoc_insertion_point(destructor:subspace.Statistics) + SharedDtor(*this); +} +inline void Statistics::SharedDtor(MessageLite& self) { + Statistics& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.server_id_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* Statistics::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Statistics(arena); +} +constexpr auto Statistics::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(Statistics, _impl_.channels_) + + decltype(Statistics::_impl_.channels_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(Statistics), alignof(Statistics), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&Statistics::PlacementNew_, + sizeof(Statistics), + alignof(Statistics)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Statistics::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Statistics_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Statistics::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Statistics::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Statistics::ByteSizeLong, + &Statistics::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Statistics, _impl_._cached_size_), + false, + }, + &Statistics::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Statistics::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 37, 2> Statistics::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Statistics>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string server_id = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(Statistics, _impl_.server_id_)}}, + // int64 timestamp = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Statistics, _impl_.timestamp_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(Statistics, _impl_.timestamp_)}}, + // repeated .subspace.ChannelStatsProto channels = 3; + {::_pbi::TcParser::FastMtR1, + {26, 63, 0, PROTOBUF_FIELD_OFFSET(Statistics, _impl_.channels_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string server_id = 1; + {PROTOBUF_FIELD_OFFSET(Statistics, _impl_.server_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int64 timestamp = 2; + {PROTOBUF_FIELD_OFFSET(Statistics, _impl_.timestamp_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // repeated .subspace.ChannelStatsProto channels = 3; + {PROTOBUF_FIELD_OFFSET(Statistics, _impl_.channels_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ChannelStatsProto>()}, + }}, {{ + "\23\11\0\0\0\0\0\0" + "subspace.Statistics" + "server_id" + }}, +}; + +PROTOBUF_NOINLINE void Statistics::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Statistics) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channels_.Clear(); + _impl_.server_id_.ClearToEmpty(); + _impl_.timestamp_ = ::int64_t{0}; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Statistics::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Statistics& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Statistics::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Statistics& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Statistics) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string server_id = 1; + if (!this_._internal_server_id().empty()) { + const std::string& _s = this_._internal_server_id(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.Statistics.server_id"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int64 timestamp = 2; + if (this_._internal_timestamp() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<2>( + stream, this_._internal_timestamp(), target); + } + + // repeated .subspace.ChannelStatsProto channels = 3; + for (unsigned i = 0, n = static_cast( + this_._internal_channels_size()); + i < n; i++) { + const auto& repfield = this_._internal_channels().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, repfield, repfield.GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Statistics) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Statistics::ByteSizeLong(const MessageLite& base) { + const Statistics& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Statistics::ByteSizeLong() const { + const Statistics& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Statistics) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .subspace.ChannelStatsProto channels = 3; + { + total_size += 1UL * this_._internal_channels_size(); + for (const auto& msg : this_._internal_channels()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + { + // string server_id = 1; + if (!this_._internal_server_id().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_server_id()); + } + // int64 timestamp = 2; + if (this_._internal_timestamp() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_timestamp()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Statistics::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Statistics) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_channels()->MergeFrom( + from._internal_channels()); + if (!from._internal_server_id().empty()) { + _this->_internal_set_server_id(from._internal_server_id()); + } + if (from._internal_timestamp() != 0) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Statistics::CopyFrom(const Statistics& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Statistics) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Statistics::InternalSwap(Statistics* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.channels_.InternalSwap(&other->_impl_.channels_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.server_id_, &other->_impl_.server_id_, arena); + swap(_impl_.timestamp_, other->_impl_.timestamp_); +} + +::google::protobuf::Metadata Statistics::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ChannelAddress::_Internal { + public: +}; + +ChannelAddress::ChannelAddress(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ChannelAddress) +} +inline PROTOBUF_NDEBUG_INLINE ChannelAddress::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ChannelAddress& from_msg) + : address_(arena, from.address_), + _cached_size_{0} {} + +ChannelAddress::ChannelAddress( + ::google::protobuf::Arena* arena, + const ChannelAddress& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ChannelAddress* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.port_ = from._impl_.port_; + + // @@protoc_insertion_point(copy_constructor:subspace.ChannelAddress) +} +inline PROTOBUF_NDEBUG_INLINE ChannelAddress::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : address_(arena), + _cached_size_{0} {} + +inline void ChannelAddress::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.port_ = {}; +} +ChannelAddress::~ChannelAddress() { + // @@protoc_insertion_point(destructor:subspace.ChannelAddress) + SharedDtor(*this); +} +inline void ChannelAddress::SharedDtor(MessageLite& self) { + ChannelAddress& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.address_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ChannelAddress::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ChannelAddress(arena); +} +constexpr auto ChannelAddress::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ChannelAddress), + alignof(ChannelAddress)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ChannelAddress::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ChannelAddress_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ChannelAddress::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ChannelAddress::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ChannelAddress::ByteSizeLong, + &ChannelAddress::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ChannelAddress, _impl_._cached_size_), + false, + }, + &ChannelAddress::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ChannelAddress::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> ChannelAddress::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ChannelAddress>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 port = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ChannelAddress, _impl_.port_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelAddress, _impl_.port_)}}, + // bytes address = 1; + {::_pbi::TcParser::FastBS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ChannelAddress, _impl_.address_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes address = 1; + {PROTOBUF_FIELD_OFFSET(ChannelAddress, _impl_.address_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // int32 port = 2; + {PROTOBUF_FIELD_OFFSET(ChannelAddress, _impl_.port_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ChannelAddress::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ChannelAddress) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.address_.ClearToEmpty(); + _impl_.port_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ChannelAddress::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ChannelAddress& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ChannelAddress::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ChannelAddress& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ChannelAddress) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // bytes address = 1; + if (!this_._internal_address().empty()) { + const std::string& _s = this_._internal_address(); + target = stream->WriteBytesMaybeAliased(1, _s, target); + } + + // int32 port = 2; + if (this_._internal_port() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_port(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ChannelAddress) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ChannelAddress::ByteSizeLong(const MessageLite& base) { + const ChannelAddress& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ChannelAddress::ByteSizeLong() const { + const ChannelAddress& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ChannelAddress) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // bytes address = 1; + if (!this_._internal_address().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_address()); + } + // int32 port = 2; + if (this_._internal_port() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_port()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ChannelAddress::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ChannelAddress) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_address().empty()) { + _this->_internal_set_address(from._internal_address()); + } + if (from._internal_port() != 0) { + _this->_impl_.port_ = from._impl_.port_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ChannelAddress::CopyFrom(const ChannelAddress& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ChannelAddress) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ChannelAddress::InternalSwap(ChannelAddress* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.address_, &other->_impl_.address_, arena); + swap(_impl_.port_, other->_impl_.port_); +} + +::google::protobuf::Metadata ChannelAddress::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Subscribed::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(Subscribed, _impl_._has_bits_); +}; + +Subscribed::Subscribed(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Subscribed) +} +inline PROTOBUF_NDEBUG_INLINE Subscribed::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Subscribed& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + channel_name_(arena, from.channel_name_) {} + +Subscribed::Subscribed( + ::google::protobuf::Arena* arena, + const Subscribed& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Subscribed* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.retirement_socket_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::subspace::ChannelAddress>( + arena, *from._impl_.retirement_socket_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, slot_size_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, slot_size_), + offsetof(Impl_, metadata_size_) - + offsetof(Impl_, slot_size_) + + sizeof(Impl_::metadata_size_)); + + // @@protoc_insertion_point(copy_constructor:subspace.Subscribed) +} +inline PROTOBUF_NDEBUG_INLINE Subscribed::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + channel_name_(arena) {} + +inline void Subscribed::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, retirement_socket_), + 0, + offsetof(Impl_, metadata_size_) - + offsetof(Impl_, retirement_socket_) + + sizeof(Impl_::metadata_size_)); +} +Subscribed::~Subscribed() { + // @@protoc_insertion_point(destructor:subspace.Subscribed) + SharedDtor(*this); +} +inline void Subscribed::SharedDtor(MessageLite& self) { + Subscribed& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + delete this_._impl_.retirement_socket_; + this_._impl_.~Impl_(); +} + +inline void* Subscribed::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Subscribed(arena); +} +constexpr auto Subscribed::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Subscribed), + alignof(Subscribed)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Subscribed::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Subscribed_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Subscribed::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Subscribed::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Subscribed::ByteSizeLong, + &Subscribed::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Subscribed, _impl_._cached_size_), + false, + }, + &Subscribed::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Subscribed::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 10, 1, 48, 2> Subscribed::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Subscribed, _impl_._has_bits_), + 0, // no _extensions_ + 10, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966272, // skipmap + offsetof(decltype(_table_), field_entries), + 10, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Subscribed>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.channel_name_)}}, + // int32 slot_size = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Subscribed, _impl_.slot_size_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.slot_size_)}}, + // int32 num_slots = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Subscribed, _impl_.num_slots_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.num_slots_)}}, + // bool reliable = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.reliable_)}}, + // bool notify_retirement = 5; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.notify_retirement_)}}, + // .subspace.ChannelAddress retirement_socket = 6; + {::_pbi::TcParser::FastMtS1, + {50, 0, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.retirement_socket_)}}, + // int32 checksum_size = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Subscribed, _impl_.checksum_size_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.checksum_size_)}}, + // int32 metadata_size = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Subscribed, _impl_.metadata_size_), 63>(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.metadata_size_)}}, + // bool split_buffers = 9; + {::_pbi::TcParser::SingularVarintNoZag1(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.split_buffers_)}}, + // bool split_buffers_over_bridge = 10; + {::_pbi::TcParser::SingularVarintNoZag1(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.split_buffers_over_bridge_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.channel_name_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 slot_size = 2; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.slot_size_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_slots = 3; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.num_slots_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool reliable = 4; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.reliable_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool notify_retirement = 5; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.notify_retirement_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // .subspace.ChannelAddress retirement_socket = 6; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.retirement_socket_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // int32 checksum_size = 7; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.checksum_size_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 metadata_size = 8; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.metadata_size_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool split_buffers = 9; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.split_buffers_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool split_buffers_over_bridge = 10; + {PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.split_buffers_over_bridge_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ChannelAddress>()}, + }}, {{ + "\23\14\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.Subscribed" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void Subscribed::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Subscribed) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.retirement_socket_ != nullptr); + _impl_.retirement_socket_->Clear(); + } + ::memset(&_impl_.slot_size_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.metadata_size_) - + reinterpret_cast(&_impl_.slot_size_)) + sizeof(_impl_.metadata_size_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Subscribed::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Subscribed& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Subscribed::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Subscribed& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Subscribed) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.Subscribed.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 slot_size = 2; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_slot_size(), target); + } + + // int32 num_slots = 3; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_num_slots(), target); + } + + // bool reliable = 4; + if (this_._internal_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_reliable(), target); + } + + // bool notify_retirement = 5; + if (this_._internal_notify_retirement() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_notify_retirement(), target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .subspace.ChannelAddress retirement_socket = 6; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 6, *this_._impl_.retirement_socket_, this_._impl_.retirement_socket_->GetCachedSize(), target, + stream); + } + + // int32 checksum_size = 7; + if (this_._internal_checksum_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<7>( + stream, this_._internal_checksum_size(), target); + } + + // int32 metadata_size = 8; + if (this_._internal_metadata_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<8>( + stream, this_._internal_metadata_size(), target); + } + + // bool split_buffers = 9; + if (this_._internal_split_buffers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 9, this_._internal_split_buffers(), target); + } + + // bool split_buffers_over_bridge = 10; + if (this_._internal_split_buffers_over_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 10, this_._internal_split_buffers_over_bridge(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Subscribed) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Subscribed::ByteSizeLong(const MessageLite& base) { + const Subscribed& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Subscribed::ByteSizeLong() const { + const Subscribed& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Subscribed) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + } + { + // .subspace.ChannelAddress retirement_socket = 6; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.retirement_socket_); + } + } + { + // int32 slot_size = 2; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // int32 num_slots = 3; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + // int32 checksum_size = 7; + if (this_._internal_checksum_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_checksum_size()); + } + // bool reliable = 4; + if (this_._internal_reliable() != 0) { + total_size += 2; + } + // bool notify_retirement = 5; + if (this_._internal_notify_retirement() != 0) { + total_size += 2; + } + // bool split_buffers = 9; + if (this_._internal_split_buffers() != 0) { + total_size += 2; + } + // bool split_buffers_over_bridge = 10; + if (this_._internal_split_buffers_over_bridge() != 0) { + total_size += 2; + } + // int32 metadata_size = 8; + if (this_._internal_metadata_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_metadata_size()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Subscribed::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Subscribed) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.retirement_socket_ != nullptr); + if (_this->_impl_.retirement_socket_ == nullptr) { + _this->_impl_.retirement_socket_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ChannelAddress>(arena, *from._impl_.retirement_socket_); + } else { + _this->_impl_.retirement_socket_->MergeFrom(*from._impl_.retirement_socket_); + } + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + if (from._internal_checksum_size() != 0) { + _this->_impl_.checksum_size_ = from._impl_.checksum_size_; + } + if (from._internal_reliable() != 0) { + _this->_impl_.reliable_ = from._impl_.reliable_; + } + if (from._internal_notify_retirement() != 0) { + _this->_impl_.notify_retirement_ = from._impl_.notify_retirement_; + } + if (from._internal_split_buffers() != 0) { + _this->_impl_.split_buffers_ = from._impl_.split_buffers_; + } + if (from._internal_split_buffers_over_bridge() != 0) { + _this->_impl_.split_buffers_over_bridge_ = from._impl_.split_buffers_over_bridge_; + } + if (from._internal_metadata_size() != 0) { + _this->_impl_.metadata_size_ = from._impl_.metadata_size_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Subscribed::CopyFrom(const Subscribed& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Subscribed) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Subscribed::InternalSwap(Subscribed* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.metadata_size_) + + sizeof(Subscribed::_impl_.metadata_size_) + - PROTOBUF_FIELD_OFFSET(Subscribed, _impl_.retirement_socket_)>( + reinterpret_cast(&_impl_.retirement_socket_), + reinterpret_cast(&other->_impl_.retirement_socket_)); +} + +::google::protobuf::Metadata Subscribed::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RetirementNotification::_Internal { + public: +}; + +RetirementNotification::RetirementNotification(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RetirementNotification) +} +RetirementNotification::RetirementNotification( + ::google::protobuf::Arena* arena, const RetirementNotification& from) + : RetirementNotification(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE RetirementNotification::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RetirementNotification::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.slot_id_ = {}; +} +RetirementNotification::~RetirementNotification() { + // @@protoc_insertion_point(destructor:subspace.RetirementNotification) + SharedDtor(*this); +} +inline void RetirementNotification::SharedDtor(MessageLite& self) { + RetirementNotification& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* RetirementNotification::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RetirementNotification(arena); +} +constexpr auto RetirementNotification::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RetirementNotification), + alignof(RetirementNotification)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RetirementNotification::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RetirementNotification_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RetirementNotification::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RetirementNotification::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RetirementNotification::ByteSizeLong, + &RetirementNotification::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RetirementNotification, _impl_._cached_size_), + false, + }, + &RetirementNotification::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RetirementNotification::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RetirementNotification::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RetirementNotification>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 slot_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RetirementNotification, _impl_.slot_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RetirementNotification, _impl_.slot_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 slot_id = 1; + {PROTOBUF_FIELD_OFFSET(RetirementNotification, _impl_.slot_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void RetirementNotification::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RetirementNotification) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.slot_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RetirementNotification::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RetirementNotification& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RetirementNotification::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RetirementNotification& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RetirementNotification) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 slot_id = 1; + if (this_._internal_slot_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this_._internal_slot_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RetirementNotification) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RetirementNotification::ByteSizeLong(const MessageLite& base) { + const RetirementNotification& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RetirementNotification::ByteSizeLong() const { + const RetirementNotification& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RetirementNotification) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // int32 slot_id = 1; + if (this_._internal_slot_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RetirementNotification::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RetirementNotification) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_slot_id() != 0) { + _this->_impl_.slot_id_ = from._impl_.slot_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RetirementNotification::CopyFrom(const RetirementNotification& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RetirementNotification) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RetirementNotification::InternalSwap(RetirementNotification* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.slot_id_, other->_impl_.slot_id_); +} + +::google::protobuf::Metadata RetirementNotification::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Discovery_Query::_Internal { + public: +}; + +Discovery_Query::Discovery_Query(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Discovery.Query) +} +inline PROTOBUF_NDEBUG_INLINE Discovery_Query::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Discovery_Query& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +Discovery_Query::Discovery_Query( + ::google::protobuf::Arena* arena, + const Discovery_Query& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Discovery_Query* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.Discovery.Query) +} +inline PROTOBUF_NDEBUG_INLINE Discovery_Query::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void Discovery_Query::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +Discovery_Query::~Discovery_Query() { + // @@protoc_insertion_point(destructor:subspace.Discovery.Query) + SharedDtor(*this); +} +inline void Discovery_Query::SharedDtor(MessageLite& self) { + Discovery_Query& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* Discovery_Query::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Discovery_Query(arena); +} +constexpr auto Discovery_Query::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Discovery_Query), + alignof(Discovery_Query)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Discovery_Query::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Discovery_Query_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Discovery_Query::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Discovery_Query::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Discovery_Query::ByteSizeLong, + &Discovery_Query::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Discovery_Query, _impl_._cached_size_), + false, + }, + &Discovery_Query::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Discovery_Query::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 45, 2> Discovery_Query::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Discovery_Query>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Query, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(Discovery_Query, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\30\14\0\0\0\0\0\0" + "subspace.Discovery.Query" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void Discovery_Query::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Discovery.Query) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Discovery_Query::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Discovery_Query& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Discovery_Query::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Discovery_Query& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Discovery.Query) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.Discovery.Query.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Discovery.Query) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Discovery_Query::ByteSizeLong(const MessageLite& base) { + const Discovery_Query& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Discovery_Query::ByteSizeLong() const { + const Discovery_Query& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Discovery.Query) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Discovery_Query::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Discovery.Query) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Discovery_Query::CopyFrom(const Discovery_Query& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Discovery.Query) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Discovery_Query::InternalSwap(Discovery_Query* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); +} + +::google::protobuf::Metadata Discovery_Query::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Discovery_Advertise::_Internal { + public: +}; + +Discovery_Advertise::Discovery_Advertise(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Discovery.Advertise) +} +inline PROTOBUF_NDEBUG_INLINE Discovery_Advertise::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Discovery_Advertise& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +Discovery_Advertise::Discovery_Advertise( + ::google::protobuf::Arena* arena, + const Discovery_Advertise& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Discovery_Advertise* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, reliable_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, reliable_), + offsetof(Impl_, split_buffers_) - + offsetof(Impl_, reliable_) + + sizeof(Impl_::split_buffers_)); + + // @@protoc_insertion_point(copy_constructor:subspace.Discovery.Advertise) +} +inline PROTOBUF_NDEBUG_INLINE Discovery_Advertise::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void Discovery_Advertise::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, reliable_), + 0, + offsetof(Impl_, split_buffers_) - + offsetof(Impl_, reliable_) + + sizeof(Impl_::split_buffers_)); +} +Discovery_Advertise::~Discovery_Advertise() { + // @@protoc_insertion_point(destructor:subspace.Discovery.Advertise) + SharedDtor(*this); +} +inline void Discovery_Advertise::SharedDtor(MessageLite& self) { + Discovery_Advertise& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* Discovery_Advertise::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Discovery_Advertise(arena); +} +constexpr auto Discovery_Advertise::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Discovery_Advertise), + alignof(Discovery_Advertise)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Discovery_Advertise::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Discovery_Advertise_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Discovery_Advertise::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Discovery_Advertise::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Discovery_Advertise::ByteSizeLong, + &Discovery_Advertise::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_._cached_size_), + false, + }, + &Discovery_Advertise::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Discovery_Advertise::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 49, 2> Discovery_Advertise::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Discovery_Advertise>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool split_buffers = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.split_buffers_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.channel_name_)}}, + // bool reliable = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.reliable_)}}, + // bool notify_retirement = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.notify_retirement_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool reliable = 2; + {PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool notify_retirement = 3; + {PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.notify_retirement_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool split_buffers = 4; + {PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.split_buffers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\34\14\0\0\0\0\0\0" + "subspace.Discovery.Advertise" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void Discovery_Advertise::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Discovery.Advertise) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.reliable_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.split_buffers_) - + reinterpret_cast(&_impl_.reliable_)) + sizeof(_impl_.split_buffers_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Discovery_Advertise::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Discovery_Advertise& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Discovery_Advertise::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Discovery_Advertise& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Discovery.Advertise) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.Discovery.Advertise.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // bool reliable = 2; + if (this_._internal_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_reliable(), target); + } + + // bool notify_retirement = 3; + if (this_._internal_notify_retirement() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_notify_retirement(), target); + } + + // bool split_buffers = 4; + if (this_._internal_split_buffers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_split_buffers(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Discovery.Advertise) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Discovery_Advertise::ByteSizeLong(const MessageLite& base) { + const Discovery_Advertise& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Discovery_Advertise::ByteSizeLong() const { + const Discovery_Advertise& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Discovery.Advertise) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // bool reliable = 2; + if (this_._internal_reliable() != 0) { + total_size += 2; + } + // bool notify_retirement = 3; + if (this_._internal_notify_retirement() != 0) { + total_size += 2; + } + // bool split_buffers = 4; + if (this_._internal_split_buffers() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Discovery_Advertise::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Discovery.Advertise) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_reliable() != 0) { + _this->_impl_.reliable_ = from._impl_.reliable_; + } + if (from._internal_notify_retirement() != 0) { + _this->_impl_.notify_retirement_ = from._impl_.notify_retirement_; + } + if (from._internal_split_buffers() != 0) { + _this->_impl_.split_buffers_ = from._impl_.split_buffers_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Discovery_Advertise::CopyFrom(const Discovery_Advertise& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Discovery.Advertise) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Discovery_Advertise::InternalSwap(Discovery_Advertise* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.split_buffers_) + + sizeof(Discovery_Advertise::_impl_.split_buffers_) + - PROTOBUF_FIELD_OFFSET(Discovery_Advertise, _impl_.reliable_)>( + reinterpret_cast(&_impl_.reliable_), + reinterpret_cast(&other->_impl_.reliable_)); +} + +::google::protobuf::Metadata Discovery_Advertise::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Discovery_Subscribe::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_._has_bits_); +}; + +Discovery_Subscribe::Discovery_Subscribe(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Discovery.Subscribe) +} +inline PROTOBUF_NDEBUG_INLINE Discovery_Subscribe::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Discovery_Subscribe& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + channel_name_(arena, from.channel_name_) {} + +Discovery_Subscribe::Discovery_Subscribe( + ::google::protobuf::Arena* arena, + const Discovery_Subscribe& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Discovery_Subscribe* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.receiver_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::subspace::ChannelAddress>( + arena, *from._impl_.receiver_) + : nullptr; + _impl_.reliable_ = from._impl_.reliable_; + + // @@protoc_insertion_point(copy_constructor:subspace.Discovery.Subscribe) +} +inline PROTOBUF_NDEBUG_INLINE Discovery_Subscribe::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + channel_name_(arena) {} + +inline void Discovery_Subscribe::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, receiver_), + 0, + offsetof(Impl_, reliable_) - + offsetof(Impl_, receiver_) + + sizeof(Impl_::reliable_)); +} +Discovery_Subscribe::~Discovery_Subscribe() { + // @@protoc_insertion_point(destructor:subspace.Discovery.Subscribe) + SharedDtor(*this); +} +inline void Discovery_Subscribe::SharedDtor(MessageLite& self) { + Discovery_Subscribe& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + delete this_._impl_.receiver_; + this_._impl_.~Impl_(); +} + +inline void* Discovery_Subscribe::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Discovery_Subscribe(arena); +} +constexpr auto Discovery_Subscribe::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Discovery_Subscribe), + alignof(Discovery_Subscribe)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Discovery_Subscribe::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Discovery_Subscribe_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Discovery_Subscribe::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Discovery_Subscribe::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Discovery_Subscribe::ByteSizeLong, + &Discovery_Subscribe::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_._cached_size_), + false, + }, + &Discovery_Subscribe::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Discovery_Subscribe::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 49, 2> Discovery_Subscribe::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_._has_bits_), + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Discovery_Subscribe>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.channel_name_)}}, + // .subspace.ChannelAddress receiver = 2; + {::_pbi::TcParser::FastMtS1, + {18, 0, 0, PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.receiver_)}}, + // bool reliable = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.reliable_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.channel_name_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .subspace.ChannelAddress receiver = 2; + {PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.receiver_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool reliable = 3; + {PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.reliable_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ChannelAddress>()}, + }}, {{ + "\34\14\0\0\0\0\0\0" + "subspace.Discovery.Subscribe" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void Discovery_Subscribe::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Discovery.Subscribe) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.receiver_ != nullptr); + _impl_.receiver_->Clear(); + } + _impl_.reliable_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Discovery_Subscribe::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Discovery_Subscribe& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Discovery_Subscribe::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Discovery_Subscribe& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Discovery.Subscribe) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.Discovery.Subscribe.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .subspace.ChannelAddress receiver = 2; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.receiver_, this_._impl_.receiver_->GetCachedSize(), target, + stream); + } + + // bool reliable = 3; + if (this_._internal_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_reliable(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Discovery.Subscribe) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Discovery_Subscribe::ByteSizeLong(const MessageLite& base) { + const Discovery_Subscribe& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Discovery_Subscribe::ByteSizeLong() const { + const Discovery_Subscribe& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Discovery.Subscribe) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + } + { + // .subspace.ChannelAddress receiver = 2; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.receiver_); + } + } + { + // bool reliable = 3; + if (this_._internal_reliable() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Discovery_Subscribe::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Discovery.Subscribe) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.receiver_ != nullptr); + if (_this->_impl_.receiver_ == nullptr) { + _this->_impl_.receiver_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ChannelAddress>(arena, *from._impl_.receiver_); + } else { + _this->_impl_.receiver_->MergeFrom(*from._impl_.receiver_); + } + } + if (from._internal_reliable() != 0) { + _this->_impl_.reliable_ = from._impl_.reliable_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Discovery_Subscribe::CopyFrom(const Discovery_Subscribe& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Discovery.Subscribe) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Discovery_Subscribe::InternalSwap(Discovery_Subscribe* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.reliable_) + + sizeof(Discovery_Subscribe::_impl_.reliable_) + - PROTOBUF_FIELD_OFFSET(Discovery_Subscribe, _impl_.receiver_)>( + reinterpret_cast(&_impl_.receiver_), + reinterpret_cast(&other->_impl_.receiver_)); +} + +::google::protobuf::Metadata Discovery_Subscribe::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class Discovery::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::subspace::Discovery, _impl_._oneof_case_); +}; + +void Discovery::set_allocated_query(::subspace::Discovery_Query* query) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_data(); + if (query) { + ::google::protobuf::Arena* submessage_arena = query->GetArena(); + if (message_arena != submessage_arena) { + query = ::google::protobuf::internal::GetOwnedMessage(message_arena, query, submessage_arena); + } + set_has_query(); + _impl_.data_.query_ = query; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.query) +} +void Discovery::set_allocated_advertise(::subspace::Discovery_Advertise* advertise) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_data(); + if (advertise) { + ::google::protobuf::Arena* submessage_arena = advertise->GetArena(); + if (message_arena != submessage_arena) { + advertise = ::google::protobuf::internal::GetOwnedMessage(message_arena, advertise, submessage_arena); + } + set_has_advertise(); + _impl_.data_.advertise_ = advertise; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.advertise) +} +void Discovery::set_allocated_subscribe(::subspace::Discovery_Subscribe* subscribe) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_data(); + if (subscribe) { + ::google::protobuf::Arena* submessage_arena = subscribe->GetArena(); + if (message_arena != submessage_arena) { + subscribe = ::google::protobuf::internal::GetOwnedMessage(message_arena, subscribe, submessage_arena); + } + set_has_subscribe(); + _impl_.data_.subscribe_ = subscribe; + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.subscribe) +} +Discovery::Discovery(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.Discovery) +} +inline PROTOBUF_NDEBUG_INLINE Discovery::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::Discovery& from_msg) + : server_id_(arena, from.server_id_), + data_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +Discovery::Discovery( + ::google::protobuf::Arena* arena, + const Discovery& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Discovery* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.port_ = from._impl_.port_; + switch (data_case()) { + case DATA_NOT_SET: + break; + case kQuery: + _impl_.data_.query_ = ::google::protobuf::Message::CopyConstruct<::subspace::Discovery_Query>(arena, *from._impl_.data_.query_); + break; + case kAdvertise: + _impl_.data_.advertise_ = ::google::protobuf::Message::CopyConstruct<::subspace::Discovery_Advertise>(arena, *from._impl_.data_.advertise_); + break; + case kSubscribe: + _impl_.data_.subscribe_ = ::google::protobuf::Message::CopyConstruct<::subspace::Discovery_Subscribe>(arena, *from._impl_.data_.subscribe_); + break; + } + + // @@protoc_insertion_point(copy_constructor:subspace.Discovery) +} +inline PROTOBUF_NDEBUG_INLINE Discovery::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : server_id_(arena), + data_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void Discovery::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.port_ = {}; +} +Discovery::~Discovery() { + // @@protoc_insertion_point(destructor:subspace.Discovery) + SharedDtor(*this); +} +inline void Discovery::SharedDtor(MessageLite& self) { + Discovery& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.server_id_.Destroy(); + if (this_.has_data()) { + this_.clear_data(); + } + this_._impl_.~Impl_(); +} + +void Discovery::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:subspace.Discovery) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (data_case()) { + case kQuery: { + if (GetArena() == nullptr) { + delete _impl_.data_.query_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.data_.query_); + } + break; + } + case kAdvertise: { + if (GetArena() == nullptr) { + delete _impl_.data_.advertise_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.data_.advertise_); + } + break; + } + case kSubscribe: { + if (GetArena() == nullptr) { + delete _impl_.data_.subscribe_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.data_.subscribe_); + } + break; + } + case DATA_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = DATA_NOT_SET; +} + + +inline void* Discovery::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Discovery(arena); +} +constexpr auto Discovery::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Discovery), + alignof(Discovery)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull Discovery::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_Discovery_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Discovery::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Discovery::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &Discovery::ByteSizeLong, + &Discovery::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Discovery, _impl_._cached_size_), + false, + }, + &Discovery::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* Discovery::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 5, 3, 36, 2> Discovery::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::Discovery>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 port = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Discovery, _impl_.port_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery, _impl_.port_)}}, + // string server_id = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(Discovery, _impl_.server_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string server_id = 1; + {PROTOBUF_FIELD_OFFSET(Discovery, _impl_.server_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 port = 2; + {PROTOBUF_FIELD_OFFSET(Discovery, _impl_.port_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // .subspace.Discovery.Query query = 3; + {PROTOBUF_FIELD_OFFSET(Discovery, _impl_.data_.query_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.Discovery.Advertise advertise = 4; + {PROTOBUF_FIELD_OFFSET(Discovery, _impl_.data_.advertise_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.Discovery.Subscribe subscribe = 5; + {PROTOBUF_FIELD_OFFSET(Discovery, _impl_.data_.subscribe_), _Internal::kOneofCaseOffset + 0, 2, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::Discovery_Query>()}, + {::_pbi::TcParser::GetTable<::subspace::Discovery_Advertise>()}, + {::_pbi::TcParser::GetTable<::subspace::Discovery_Subscribe>()}, + }}, {{ + "\22\11\0\0\0\0\0\0" + "subspace.Discovery" + "server_id" + }}, +}; + +PROTOBUF_NOINLINE void Discovery::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.Discovery) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.server_id_.ClearToEmpty(); + _impl_.port_ = 0; + clear_data(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Discovery::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Discovery& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Discovery::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Discovery& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.Discovery) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string server_id = 1; + if (!this_._internal_server_id().empty()) { + const std::string& _s = this_._internal_server_id(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.Discovery.server_id"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 port = 2; + if (this_._internal_port() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_port(), target); + } + + switch (this_.data_case()) { + case kQuery: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.data_.query_, this_._impl_.data_.query_->GetCachedSize(), target, + stream); + break; + } + case kAdvertise: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.data_.advertise_, this_._impl_.data_.advertise_->GetCachedSize(), target, + stream); + break; + } + case kSubscribe: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 5, *this_._impl_.data_.subscribe_, this_._impl_.data_.subscribe_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.Discovery) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Discovery::ByteSizeLong(const MessageLite& base) { + const Discovery& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Discovery::ByteSizeLong() const { + const Discovery& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.Discovery) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string server_id = 1; + if (!this_._internal_server_id().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_server_id()); + } + // int32 port = 2; + if (this_._internal_port() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_port()); + } + } + switch (this_.data_case()) { + // .subspace.Discovery.Query query = 3; + case kQuery: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.data_.query_); + break; + } + // .subspace.Discovery.Advertise advertise = 4; + case kAdvertise: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.data_.advertise_); + break; + } + // .subspace.Discovery.Subscribe subscribe = 5; + case kSubscribe: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.data_.subscribe_); + break; + } + case DATA_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void Discovery::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.Discovery) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_server_id().empty()) { + _this->_internal_set_server_id(from._internal_server_id()); + } + if (from._internal_port() != 0) { + _this->_impl_.port_ = from._impl_.port_; + } + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_data(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kQuery: { + if (oneof_needs_init) { + _this->_impl_.data_.query_ = + ::google::protobuf::Message::CopyConstruct<::subspace::Discovery_Query>(arena, *from._impl_.data_.query_); + } else { + _this->_impl_.data_.query_->MergeFrom(from._internal_query()); + } + break; + } + case kAdvertise: { + if (oneof_needs_init) { + _this->_impl_.data_.advertise_ = + ::google::protobuf::Message::CopyConstruct<::subspace::Discovery_Advertise>(arena, *from._impl_.data_.advertise_); + } else { + _this->_impl_.data_.advertise_->MergeFrom(from._internal_advertise()); + } + break; + } + case kSubscribe: { + if (oneof_needs_init) { + _this->_impl_.data_.subscribe_ = + ::google::protobuf::Message::CopyConstruct<::subspace::Discovery_Subscribe>(arena, *from._impl_.data_.subscribe_); + } else { + _this->_impl_.data_.subscribe_->MergeFrom(from._internal_subscribe()); + } + break; + } + case DATA_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Discovery::CopyFrom(const Discovery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.Discovery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Discovery::InternalSwap(Discovery* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.server_id_, &other->_impl_.server_id_, arena); + swap(_impl_.port_, other->_impl_.port_); + swap(_impl_.data_, other->_impl_.data_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::google::protobuf::Metadata Discovery::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcOpenRequest::_Internal { + public: +}; + +RpcOpenRequest::RpcOpenRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:subspace.RpcOpenRequest) +} +RpcOpenRequest::RpcOpenRequest( + ::google::protobuf::Arena* arena, + const RpcOpenRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcOpenRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcOpenRequest) +} + +inline void* RpcOpenRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcOpenRequest(arena); +} +constexpr auto RpcOpenRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RpcOpenRequest), + alignof(RpcOpenRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcOpenRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcOpenRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcOpenRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcOpenRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &RpcOpenRequest::ByteSizeLong, + &RpcOpenRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcOpenRequest, _impl_._cached_size_), + false, + }, + &RpcOpenRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcOpenRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> RpcOpenRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcOpenRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata RpcOpenRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcOpenResponse_RequestChannel::_Internal { + public: +}; + +RpcOpenResponse_RequestChannel::RpcOpenResponse_RequestChannel(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcOpenResponse.RequestChannel) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse_RequestChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcOpenResponse_RequestChannel& from_msg) + : name_(arena, from.name_), + type_(arena, from.type_), + _cached_size_{0} {} + +RpcOpenResponse_RequestChannel::RpcOpenResponse_RequestChannel( + ::google::protobuf::Arena* arena, + const RpcOpenResponse_RequestChannel& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcOpenResponse_RequestChannel* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, slot_size_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, slot_size_), + offsetof(Impl_, num_slots_) - + offsetof(Impl_, slot_size_) + + sizeof(Impl_::num_slots_)); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcOpenResponse.RequestChannel) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse_RequestChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : name_(arena), + type_(arena), + _cached_size_{0} {} + +inline void RpcOpenResponse_RequestChannel::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, slot_size_), + 0, + offsetof(Impl_, num_slots_) - + offsetof(Impl_, slot_size_) + + sizeof(Impl_::num_slots_)); +} +RpcOpenResponse_RequestChannel::~RpcOpenResponse_RequestChannel() { + // @@protoc_insertion_point(destructor:subspace.RpcOpenResponse.RequestChannel) + SharedDtor(*this); +} +inline void RpcOpenResponse_RequestChannel::SharedDtor(MessageLite& self) { + RpcOpenResponse_RequestChannel& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.name_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RpcOpenResponse_RequestChannel::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcOpenResponse_RequestChannel(arena); +} +constexpr auto RpcOpenResponse_RequestChannel::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcOpenResponse_RequestChannel), + alignof(RpcOpenResponse_RequestChannel)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcOpenResponse_RequestChannel::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcOpenResponse_RequestChannel_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcOpenResponse_RequestChannel::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcOpenResponse_RequestChannel::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcOpenResponse_RequestChannel::ByteSizeLong, + &RpcOpenResponse_RequestChannel::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_._cached_size_), + false, + }, + &RpcOpenResponse_RequestChannel::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcOpenResponse_RequestChannel::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 56, 2> RpcOpenResponse_RequestChannel::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse_RequestChannel>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string type = 4; + {::_pbi::TcParser::FastUS1, + {34, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.type_)}}, + // string name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.name_)}}, + // int32 slot_size = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcOpenResponse_RequestChannel, _impl_.slot_size_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.slot_size_)}}, + // int32 num_slots = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcOpenResponse_RequestChannel, _impl_.num_slots_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.num_slots_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string name = 1; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 slot_size = 2; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.slot_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_slots = 3; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.num_slots_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // string type = 4; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\47\4\0\0\4\0\0\0" + "subspace.RpcOpenResponse.RequestChannel" + "name" + "type" + }}, +}; + +PROTOBUF_NOINLINE void RpcOpenResponse_RequestChannel::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcOpenResponse.RequestChannel) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.name_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + ::memset(&_impl_.slot_size_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.num_slots_) - + reinterpret_cast(&_impl_.slot_size_)) + sizeof(_impl_.num_slots_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcOpenResponse_RequestChannel::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcOpenResponse_RequestChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcOpenResponse_RequestChannel::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcOpenResponse_RequestChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcOpenResponse.RequestChannel) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string name = 1; + if (!this_._internal_name().empty()) { + const std::string& _s = this_._internal_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcOpenResponse.RequestChannel.name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 slot_size = 2; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_slot_size(), target); + } + + // int32 num_slots = 3; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_num_slots(), target); + } + + // string type = 4; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcOpenResponse.RequestChannel.type"); + target = stream->WriteStringMaybeAliased(4, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcOpenResponse.RequestChannel) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcOpenResponse_RequestChannel::ByteSizeLong(const MessageLite& base) { + const RpcOpenResponse_RequestChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcOpenResponse_RequestChannel::ByteSizeLong() const { + const RpcOpenResponse_RequestChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcOpenResponse.RequestChannel) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string name = 1; + if (!this_._internal_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_name()); + } + // string type = 4; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_type()); + } + // int32 slot_size = 2; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // int32 num_slots = 3; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcOpenResponse_RequestChannel::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcOpenResponse.RequestChannel) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _this->_internal_set_name(from._internal_name()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcOpenResponse_RequestChannel::CopyFrom(const RpcOpenResponse_RequestChannel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcOpenResponse.RequestChannel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcOpenResponse_RequestChannel::InternalSwap(RpcOpenResponse_RequestChannel* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.num_slots_) + + sizeof(RpcOpenResponse_RequestChannel::_impl_.num_slots_) + - PROTOBUF_FIELD_OFFSET(RpcOpenResponse_RequestChannel, _impl_.slot_size_)>( + reinterpret_cast(&_impl_.slot_size_), + reinterpret_cast(&other->_impl_.slot_size_)); +} + +::google::protobuf::Metadata RpcOpenResponse_RequestChannel::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcOpenResponse_ResponseChannel::_Internal { + public: +}; + +RpcOpenResponse_ResponseChannel::RpcOpenResponse_ResponseChannel(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcOpenResponse.ResponseChannel) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse_ResponseChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcOpenResponse_ResponseChannel& from_msg) + : name_(arena, from.name_), + type_(arena, from.type_), + _cached_size_{0} {} + +RpcOpenResponse_ResponseChannel::RpcOpenResponse_ResponseChannel( + ::google::protobuf::Arena* arena, + const RpcOpenResponse_ResponseChannel& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcOpenResponse_ResponseChannel* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcOpenResponse.ResponseChannel) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse_ResponseChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : name_(arena), + type_(arena), + _cached_size_{0} {} + +inline void RpcOpenResponse_ResponseChannel::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +RpcOpenResponse_ResponseChannel::~RpcOpenResponse_ResponseChannel() { + // @@protoc_insertion_point(destructor:subspace.RpcOpenResponse.ResponseChannel) + SharedDtor(*this); +} +inline void RpcOpenResponse_ResponseChannel::SharedDtor(MessageLite& self) { + RpcOpenResponse_ResponseChannel& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.name_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RpcOpenResponse_ResponseChannel::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcOpenResponse_ResponseChannel(arena); +} +constexpr auto RpcOpenResponse_ResponseChannel::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcOpenResponse_ResponseChannel), + alignof(RpcOpenResponse_ResponseChannel)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcOpenResponse_ResponseChannel::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcOpenResponse_ResponseChannel_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcOpenResponse_ResponseChannel::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcOpenResponse_ResponseChannel::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcOpenResponse_ResponseChannel::ByteSizeLong, + &RpcOpenResponse_ResponseChannel::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcOpenResponse_ResponseChannel, _impl_._cached_size_), + false, + }, + &RpcOpenResponse_ResponseChannel::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcOpenResponse_ResponseChannel::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 57, 2> RpcOpenResponse_ResponseChannel::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse_ResponseChannel>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string type = 2; + {::_pbi::TcParser::FastUS1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_ResponseChannel, _impl_.type_)}}, + // string name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_ResponseChannel, _impl_.name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string name = 1; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_ResponseChannel, _impl_.name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string type = 2; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_ResponseChannel, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\50\4\4\0\0\0\0\0" + "subspace.RpcOpenResponse.ResponseChannel" + "name" + "type" + }}, +}; + +PROTOBUF_NOINLINE void RpcOpenResponse_ResponseChannel::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcOpenResponse.ResponseChannel) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.name_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcOpenResponse_ResponseChannel::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcOpenResponse_ResponseChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcOpenResponse_ResponseChannel::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcOpenResponse_ResponseChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcOpenResponse.ResponseChannel) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string name = 1; + if (!this_._internal_name().empty()) { + const std::string& _s = this_._internal_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcOpenResponse.ResponseChannel.name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // string type = 2; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcOpenResponse.ResponseChannel.type"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcOpenResponse.ResponseChannel) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcOpenResponse_ResponseChannel::ByteSizeLong(const MessageLite& base) { + const RpcOpenResponse_ResponseChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcOpenResponse_ResponseChannel::ByteSizeLong() const { + const RpcOpenResponse_ResponseChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcOpenResponse.ResponseChannel) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string name = 1; + if (!this_._internal_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_name()); + } + // string type = 2; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_type()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcOpenResponse_ResponseChannel::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcOpenResponse.ResponseChannel) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _this->_internal_set_name(from._internal_name()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcOpenResponse_ResponseChannel::CopyFrom(const RpcOpenResponse_ResponseChannel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcOpenResponse.ResponseChannel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcOpenResponse_ResponseChannel::InternalSwap(RpcOpenResponse_ResponseChannel* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); +} + +::google::protobuf::Metadata RpcOpenResponse_ResponseChannel::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcOpenResponse_Method::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_._has_bits_); +}; + +RpcOpenResponse_Method::RpcOpenResponse_Method(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcOpenResponse.Method) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse_Method::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcOpenResponse_Method& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + name_(arena, from.name_), + cancel_channel_(arena, from.cancel_channel_) {} + +RpcOpenResponse_Method::RpcOpenResponse_Method( + ::google::protobuf::Arena* arena, + const RpcOpenResponse_Method& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcOpenResponse_Method* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.request_channel_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenResponse_RequestChannel>( + arena, *from._impl_.request_channel_) + : nullptr; + _impl_.response_channel_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenResponse_ResponseChannel>( + arena, *from._impl_.response_channel_) + : nullptr; + _impl_.id_ = from._impl_.id_; + + // @@protoc_insertion_point(copy_constructor:subspace.RpcOpenResponse.Method) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse_Method::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + name_(arena), + cancel_channel_(arena) {} + +inline void RpcOpenResponse_Method::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, request_channel_), + 0, + offsetof(Impl_, id_) - + offsetof(Impl_, request_channel_) + + sizeof(Impl_::id_)); +} +RpcOpenResponse_Method::~RpcOpenResponse_Method() { + // @@protoc_insertion_point(destructor:subspace.RpcOpenResponse.Method) + SharedDtor(*this); +} +inline void RpcOpenResponse_Method::SharedDtor(MessageLite& self) { + RpcOpenResponse_Method& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.name_.Destroy(); + this_._impl_.cancel_channel_.Destroy(); + delete this_._impl_.request_channel_; + delete this_._impl_.response_channel_; + this_._impl_.~Impl_(); +} + +inline void* RpcOpenResponse_Method::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcOpenResponse_Method(arena); +} +constexpr auto RpcOpenResponse_Method::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcOpenResponse_Method), + alignof(RpcOpenResponse_Method)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcOpenResponse_Method::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcOpenResponse_Method_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcOpenResponse_Method::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcOpenResponse_Method::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcOpenResponse_Method::ByteSizeLong, + &RpcOpenResponse_Method::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_._cached_size_), + false, + }, + &RpcOpenResponse_Method::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcOpenResponse_Method::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 2, 58, 2> RpcOpenResponse_Method::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_._has_bits_), + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse_Method>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.name_)}}, + // int32 id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcOpenResponse_Method, _impl_.id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.id_)}}, + // .subspace.RpcOpenResponse.RequestChannel request_channel = 3; + {::_pbi::TcParser::FastMtS1, + {26, 0, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.request_channel_)}}, + // .subspace.RpcOpenResponse.ResponseChannel response_channel = 4; + {::_pbi::TcParser::FastMtS1, + {34, 1, 1, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.response_channel_)}}, + // string cancel_channel = 5; + {::_pbi::TcParser::FastUS1, + {42, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.cancel_channel_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string name = 1; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.name_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 id = 2; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // .subspace.RpcOpenResponse.RequestChannel request_channel = 3; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.request_channel_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RpcOpenResponse.ResponseChannel response_channel = 4; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.response_channel_), _Internal::kHasBitsOffset + 1, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string cancel_channel = 5; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.cancel_channel_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse_RequestChannel>()}, + {::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse_ResponseChannel>()}, + }}, {{ + "\37\4\0\0\0\16\0\0" + "subspace.RpcOpenResponse.Method" + "name" + "cancel_channel" + }}, +}; + +PROTOBUF_NOINLINE void RpcOpenResponse_Method::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcOpenResponse.Method) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.name_.ClearToEmpty(); + _impl_.cancel_channel_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.request_channel_ != nullptr); + _impl_.request_channel_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.response_channel_ != nullptr); + _impl_.response_channel_->Clear(); + } + } + _impl_.id_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcOpenResponse_Method::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcOpenResponse_Method& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcOpenResponse_Method::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcOpenResponse_Method& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcOpenResponse.Method) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string name = 1; + if (!this_._internal_name().empty()) { + const std::string& _s = this_._internal_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcOpenResponse.Method.name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 id = 2; + if (this_._internal_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_id(), target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .subspace.RpcOpenResponse.RequestChannel request_channel = 3; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.request_channel_, this_._impl_.request_channel_->GetCachedSize(), target, + stream); + } + + // .subspace.RpcOpenResponse.ResponseChannel response_channel = 4; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.response_channel_, this_._impl_.response_channel_->GetCachedSize(), target, + stream); + } + + // string cancel_channel = 5; + if (!this_._internal_cancel_channel().empty()) { + const std::string& _s = this_._internal_cancel_channel(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcOpenResponse.Method.cancel_channel"); + target = stream->WriteStringMaybeAliased(5, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcOpenResponse.Method) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcOpenResponse_Method::ByteSizeLong(const MessageLite& base) { + const RpcOpenResponse_Method& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcOpenResponse_Method::ByteSizeLong() const { + const RpcOpenResponse_Method& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcOpenResponse.Method) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string name = 1; + if (!this_._internal_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_name()); + } + // string cancel_channel = 5; + if (!this_._internal_cancel_channel().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_cancel_channel()); + } + } + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .subspace.RpcOpenResponse.RequestChannel request_channel = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_channel_); + } + // .subspace.RpcOpenResponse.ResponseChannel response_channel = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_channel_); + } + } + { + // int32 id = 2; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcOpenResponse_Method::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcOpenResponse.Method) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _this->_internal_set_name(from._internal_name()); + } + if (!from._internal_cancel_channel().empty()) { + _this->_internal_set_cancel_channel(from._internal_cancel_channel()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.request_channel_ != nullptr); + if (_this->_impl_.request_channel_ == nullptr) { + _this->_impl_.request_channel_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenResponse_RequestChannel>(arena, *from._impl_.request_channel_); + } else { + _this->_impl_.request_channel_->MergeFrom(*from._impl_.request_channel_); + } + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(from._impl_.response_channel_ != nullptr); + if (_this->_impl_.response_channel_ == nullptr) { + _this->_impl_.response_channel_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenResponse_ResponseChannel>(arena, *from._impl_.response_channel_); + } else { + _this->_impl_.response_channel_->MergeFrom(*from._impl_.response_channel_); + } + } + } + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcOpenResponse_Method::CopyFrom(const RpcOpenResponse_Method& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcOpenResponse.Method) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcOpenResponse_Method::InternalSwap(RpcOpenResponse_Method* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.cancel_channel_, &other->_impl_.cancel_channel_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.id_) + + sizeof(RpcOpenResponse_Method::_impl_.id_) + - PROTOBUF_FIELD_OFFSET(RpcOpenResponse_Method, _impl_.request_channel_)>( + reinterpret_cast(&_impl_.request_channel_), + reinterpret_cast(&other->_impl_.request_channel_)); +} + +::google::protobuf::Metadata RpcOpenResponse_Method::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcOpenResponse::_Internal { + public: +}; + +RpcOpenResponse::RpcOpenResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcOpenResponse) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcOpenResponse& from_msg) + : methods_{visibility, arena, from.methods_}, + _cached_size_{0} {} + +RpcOpenResponse::RpcOpenResponse( + ::google::protobuf::Arena* arena, + const RpcOpenResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcOpenResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, client_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, client_id_), + offsetof(Impl_, session_id_) - + offsetof(Impl_, client_id_) + + sizeof(Impl_::session_id_)); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcOpenResponse) +} +inline PROTOBUF_NDEBUG_INLINE RpcOpenResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : methods_{visibility, arena}, + _cached_size_{0} {} + +inline void RpcOpenResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, client_id_), + 0, + offsetof(Impl_, session_id_) - + offsetof(Impl_, client_id_) + + sizeof(Impl_::session_id_)); +} +RpcOpenResponse::~RpcOpenResponse() { + // @@protoc_insertion_point(destructor:subspace.RpcOpenResponse) + SharedDtor(*this); +} +inline void RpcOpenResponse::SharedDtor(MessageLite& self) { + RpcOpenResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* RpcOpenResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcOpenResponse(arena); +} +constexpr auto RpcOpenResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.methods_) + + decltype(RpcOpenResponse::_impl_.methods_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(RpcOpenResponse), alignof(RpcOpenResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RpcOpenResponse::PlacementNew_, + sizeof(RpcOpenResponse), + alignof(RpcOpenResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcOpenResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcOpenResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcOpenResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcOpenResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcOpenResponse::ByteSizeLong, + &RpcOpenResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_._cached_size_), + false, + }, + &RpcOpenResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcOpenResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 0, 2> RpcOpenResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 session_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcOpenResponse, _impl_.session_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.session_id_)}}, + // repeated .subspace.RpcOpenResponse.Method methods = 2; + {::_pbi::TcParser::FastMtR1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.methods_)}}, + // uint64 client_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RpcOpenResponse, _impl_.client_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.client_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 session_id = 1; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // repeated .subspace.RpcOpenResponse.Method methods = 2; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.methods_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint64 client_id = 3; + {PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.client_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse_Method>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void RpcOpenResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcOpenResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.methods_.Clear(); + ::memset(&_impl_.client_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.session_id_) - + reinterpret_cast(&_impl_.client_id_)) + sizeof(_impl_.session_id_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcOpenResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcOpenResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcOpenResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcOpenResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcOpenResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 session_id = 1; + if (this_._internal_session_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this_._internal_session_id(), target); + } + + // repeated .subspace.RpcOpenResponse.Method methods = 2; + for (unsigned i = 0, n = static_cast( + this_._internal_methods_size()); + i < n; i++) { + const auto& repfield = this_._internal_methods().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); + } + + // uint64 client_id = 3; + if (this_._internal_client_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 3, this_._internal_client_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcOpenResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcOpenResponse::ByteSizeLong(const MessageLite& base) { + const RpcOpenResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcOpenResponse::ByteSizeLong() const { + const RpcOpenResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcOpenResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .subspace.RpcOpenResponse.Method methods = 2; + { + total_size += 1UL * this_._internal_methods_size(); + for (const auto& msg : this_._internal_methods()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + { + // uint64 client_id = 3; + if (this_._internal_client_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_client_id()); + } + // int32 session_id = 1; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_session_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcOpenResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcOpenResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_methods()->MergeFrom( + from._internal_methods()); + if (from._internal_client_id() != 0) { + _this->_impl_.client_id_ = from._impl_.client_id_; + } + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcOpenResponse::CopyFrom(const RpcOpenResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcOpenResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcOpenResponse::InternalSwap(RpcOpenResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.methods_.InternalSwap(&other->_impl_.methods_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.session_id_) + + sizeof(RpcOpenResponse::_impl_.session_id_) + - PROTOBUF_FIELD_OFFSET(RpcOpenResponse, _impl_.client_id_)>( + reinterpret_cast(&_impl_.client_id_), + reinterpret_cast(&other->_impl_.client_id_)); +} + +::google::protobuf::Metadata RpcOpenResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcCloseRequest::_Internal { + public: +}; + +RpcCloseRequest::RpcCloseRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcCloseRequest) +} +RpcCloseRequest::RpcCloseRequest( + ::google::protobuf::Arena* arena, const RpcCloseRequest& from) + : RpcCloseRequest(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE RpcCloseRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RpcCloseRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.session_id_ = {}; +} +RpcCloseRequest::~RpcCloseRequest() { + // @@protoc_insertion_point(destructor:subspace.RpcCloseRequest) + SharedDtor(*this); +} +inline void RpcCloseRequest::SharedDtor(MessageLite& self) { + RpcCloseRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* RpcCloseRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcCloseRequest(arena); +} +constexpr auto RpcCloseRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RpcCloseRequest), + alignof(RpcCloseRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcCloseRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcCloseRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcCloseRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcCloseRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcCloseRequest::ByteSizeLong, + &RpcCloseRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcCloseRequest, _impl_._cached_size_), + false, + }, + &RpcCloseRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcCloseRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RpcCloseRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcCloseRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 session_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcCloseRequest, _impl_.session_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RpcCloseRequest, _impl_.session_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 session_id = 1; + {PROTOBUF_FIELD_OFFSET(RpcCloseRequest, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void RpcCloseRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcCloseRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.session_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcCloseRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcCloseRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcCloseRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcCloseRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcCloseRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 session_id = 1; + if (this_._internal_session_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this_._internal_session_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcCloseRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcCloseRequest::ByteSizeLong(const MessageLite& base) { + const RpcCloseRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcCloseRequest::ByteSizeLong() const { + const RpcCloseRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcCloseRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // int32 session_id = 1; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_session_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcCloseRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcCloseRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcCloseRequest::CopyFrom(const RpcCloseRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcCloseRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcCloseRequest::InternalSwap(RpcCloseRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.session_id_, other->_impl_.session_id_); +} + +::google::protobuf::Metadata RpcCloseRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcCloseResponse::_Internal { + public: +}; + +RpcCloseResponse::RpcCloseResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:subspace.RpcCloseResponse) +} +RpcCloseResponse::RpcCloseResponse( + ::google::protobuf::Arena* arena, + const RpcCloseResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcCloseResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcCloseResponse) +} + +inline void* RpcCloseResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcCloseResponse(arena); +} +constexpr auto RpcCloseResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RpcCloseResponse), + alignof(RpcCloseResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcCloseResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcCloseResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcCloseResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcCloseResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &RpcCloseResponse::ByteSizeLong, + &RpcCloseResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcCloseResponse, _impl_._cached_size_), + false, + }, + &RpcCloseResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcCloseResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> RpcCloseResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcCloseResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata RpcCloseResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcServerRequest::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerRequest, _impl_._oneof_case_); +}; + +void RpcServerRequest::set_allocated_open(::subspace::RpcOpenRequest* open) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (open) { + ::google::protobuf::Arena* submessage_arena = open->GetArena(); + if (message_arena != submessage_arena) { + open = ::google::protobuf::internal::GetOwnedMessage(message_arena, open, submessage_arena); + } + set_has_open(); + _impl_.request_.open_ = open; + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcServerRequest.open) +} +void RpcServerRequest::set_allocated_close(::subspace::RpcCloseRequest* close) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_request(); + if (close) { + ::google::protobuf::Arena* submessage_arena = close->GetArena(); + if (message_arena != submessage_arena) { + close = ::google::protobuf::internal::GetOwnedMessage(message_arena, close, submessage_arena); + } + set_has_close(); + _impl_.request_.close_ = close; + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcServerRequest.close) +} +RpcServerRequest::RpcServerRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcServerRequest) +} +inline PROTOBUF_NDEBUG_INLINE RpcServerRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcServerRequest& from_msg) + : request_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +RpcServerRequest::RpcServerRequest( + ::google::protobuf::Arena* arena, + const RpcServerRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcServerRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, client_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, client_id_), + offsetof(Impl_, request_id_) - + offsetof(Impl_, client_id_) + + sizeof(Impl_::request_id_)); + switch (request_case()) { + case REQUEST_NOT_SET: + break; + case kOpen: + _impl_.request_.open_ = ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenRequest>(arena, *from._impl_.request_.open_); + break; + case kClose: + _impl_.request_.close_ = ::google::protobuf::Message::CopyConstruct<::subspace::RpcCloseRequest>(arena, *from._impl_.request_.close_); + break; + } + + // @@protoc_insertion_point(copy_constructor:subspace.RpcServerRequest) +} +inline PROTOBUF_NDEBUG_INLINE RpcServerRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : request_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void RpcServerRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, client_id_), + 0, + offsetof(Impl_, request_id_) - + offsetof(Impl_, client_id_) + + sizeof(Impl_::request_id_)); +} +RpcServerRequest::~RpcServerRequest() { + // @@protoc_insertion_point(destructor:subspace.RpcServerRequest) + SharedDtor(*this); +} +inline void RpcServerRequest::SharedDtor(MessageLite& self) { + RpcServerRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + if (this_.has_request()) { + this_.clear_request(); + } + this_._impl_.~Impl_(); +} + +void RpcServerRequest::clear_request() { +// @@protoc_insertion_point(one_of_clear_start:subspace.RpcServerRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (request_case()) { + case kOpen: { + if (GetArena() == nullptr) { + delete _impl_.request_.open_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.open_); + } + break; + } + case kClose: { + if (GetArena() == nullptr) { + delete _impl_.request_.close_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.close_); + } + break; + } + case REQUEST_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = REQUEST_NOT_SET; +} + + +inline void* RpcServerRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcServerRequest(arena); +} +constexpr auto RpcServerRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RpcServerRequest), + alignof(RpcServerRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcServerRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcServerRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcServerRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcServerRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcServerRequest::ByteSizeLong, + &RpcServerRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_._cached_size_), + false, + }, + &RpcServerRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcServerRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 4, 2, 0, 2> RpcServerRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcServerRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 request_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcServerRequest, _impl_.request_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.request_id_)}}, + // uint64 client_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RpcServerRequest, _impl_.client_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.client_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint64 client_id = 1; + {PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.client_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // int32 request_id = 2; + {PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.request_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // .subspace.RpcOpenRequest open = 3; + {PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.request_.open_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RpcCloseRequest close = 4; + {PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.request_.close_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::RpcOpenRequest>()}, + {::_pbi::TcParser::GetTable<::subspace::RpcCloseRequest>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void RpcServerRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcServerRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.client_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.request_id_) - + reinterpret_cast(&_impl_.client_id_)) + sizeof(_impl_.request_id_)); + clear_request(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcServerRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcServerRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcServerRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcServerRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcServerRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint64 client_id = 1; + if (this_._internal_client_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 1, this_._internal_client_id(), target); + } + + // int32 request_id = 2; + if (this_._internal_request_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_request_id(), target); + } + + switch (this_.request_case()) { + case kOpen: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.request_.open_, this_._impl_.request_.open_->GetCachedSize(), target, + stream); + break; + } + case kClose: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.request_.close_, this_._impl_.request_.close_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcServerRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcServerRequest::ByteSizeLong(const MessageLite& base) { + const RpcServerRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcServerRequest::ByteSizeLong() const { + const RpcServerRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcServerRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint64 client_id = 1; + if (this_._internal_client_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_client_id()); + } + // int32 request_id = 2; + if (this_._internal_request_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_request_id()); + } + } + switch (this_.request_case()) { + // .subspace.RpcOpenRequest open = 3; + case kOpen: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.open_); + break; + } + // .subspace.RpcCloseRequest close = 4; + case kClose: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_.close_); + break; + } + case REQUEST_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcServerRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcServerRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_client_id() != 0) { + _this->_impl_.client_id_ = from._impl_.client_id_; + } + if (from._internal_request_id() != 0) { + _this->_impl_.request_id_ = from._impl_.request_id_; + } + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_request(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kOpen: { + if (oneof_needs_init) { + _this->_impl_.request_.open_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenRequest>(arena, *from._impl_.request_.open_); + } else { + _this->_impl_.request_.open_->MergeFrom(from._internal_open()); + } + break; + } + case kClose: { + if (oneof_needs_init) { + _this->_impl_.request_.close_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RpcCloseRequest>(arena, *from._impl_.request_.close_); + } else { + _this->_impl_.request_.close_->MergeFrom(from._internal_close()); + } + break; + } + case REQUEST_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcServerRequest::CopyFrom(const RpcServerRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcServerRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcServerRequest::InternalSwap(RpcServerRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.request_id_) + + sizeof(RpcServerRequest::_impl_.request_id_) + - PROTOBUF_FIELD_OFFSET(RpcServerRequest, _impl_.client_id_)>( + reinterpret_cast(&_impl_.client_id_), + reinterpret_cast(&other->_impl_.client_id_)); + swap(_impl_.request_, other->_impl_.request_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::google::protobuf::Metadata RpcServerRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcServerResponse::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::subspace::RpcServerResponse, _impl_._oneof_case_); +}; + +void RpcServerResponse::set_allocated_open(::subspace::RpcOpenResponse* open) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (open) { + ::google::protobuf::Arena* submessage_arena = open->GetArena(); + if (message_arena != submessage_arena) { + open = ::google::protobuf::internal::GetOwnedMessage(message_arena, open, submessage_arena); + } + set_has_open(); + _impl_.response_.open_ = open; + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcServerResponse.open) +} +void RpcServerResponse::set_allocated_close(::subspace::RpcCloseResponse* close) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_response(); + if (close) { + ::google::protobuf::Arena* submessage_arena = close->GetArena(); + if (message_arena != submessage_arena) { + close = ::google::protobuf::internal::GetOwnedMessage(message_arena, close, submessage_arena); + } + set_has_close(); + _impl_.response_.close_ = close; + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcServerResponse.close) +} +RpcServerResponse::RpcServerResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcServerResponse) +} +inline PROTOBUF_NDEBUG_INLINE RpcServerResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcServerResponse& from_msg) + : error_(arena, from.error_), + response_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +RpcServerResponse::RpcServerResponse( + ::google::protobuf::Arena* arena, + const RpcServerResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcServerResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, client_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, client_id_), + offsetof(Impl_, request_id_) - + offsetof(Impl_, client_id_) + + sizeof(Impl_::request_id_)); + switch (response_case()) { + case RESPONSE_NOT_SET: + break; + case kOpen: + _impl_.response_.open_ = ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenResponse>(arena, *from._impl_.response_.open_); + break; + case kClose: + _impl_.response_.close_ = ::google::protobuf::Message::CopyConstruct<::subspace::RpcCloseResponse>(arena, *from._impl_.response_.close_); + break; + } + + // @@protoc_insertion_point(copy_constructor:subspace.RpcServerResponse) +} +inline PROTOBUF_NDEBUG_INLINE RpcServerResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : error_(arena), + response_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void RpcServerResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, client_id_), + 0, + offsetof(Impl_, request_id_) - + offsetof(Impl_, client_id_) + + sizeof(Impl_::request_id_)); +} +RpcServerResponse::~RpcServerResponse() { + // @@protoc_insertion_point(destructor:subspace.RpcServerResponse) + SharedDtor(*this); +} +inline void RpcServerResponse::SharedDtor(MessageLite& self) { + RpcServerResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + if (this_.has_response()) { + this_.clear_response(); + } + this_._impl_.~Impl_(); +} + +void RpcServerResponse::clear_response() { +// @@protoc_insertion_point(one_of_clear_start:subspace.RpcServerResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (response_case()) { + case kOpen: { + if (GetArena() == nullptr) { + delete _impl_.response_.open_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.open_); + } + break; + } + case kClose: { + if (GetArena() == nullptr) { + delete _impl_.response_.close_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.close_); + } + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = RESPONSE_NOT_SET; +} + + +inline void* RpcServerResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcServerResponse(arena); +} +constexpr auto RpcServerResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcServerResponse), + alignof(RpcServerResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcServerResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcServerResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcServerResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcServerResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcServerResponse::ByteSizeLong, + &RpcServerResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_._cached_size_), + false, + }, + &RpcServerResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcServerResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 2, 40, 2> RpcServerResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcServerResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint64 client_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RpcServerResponse, _impl_.client_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.client_id_)}}, + // int32 request_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcServerResponse, _impl_.request_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.request_id_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + // string error = 5; + {::_pbi::TcParser::FastUS1, + {42, 63, 0, PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.error_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint64 client_id = 1; + {PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.client_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // int32 request_id = 2; + {PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.request_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // .subspace.RpcOpenResponse open = 3; + {PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.response_.open_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.RpcCloseResponse close = 4; + {PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.response_.close_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // string error = 5; + {PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.error_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::RpcOpenResponse>()}, + {::_pbi::TcParser::GetTable<::subspace::RpcCloseResponse>()}, + }}, {{ + "\32\0\0\0\0\5\0\0" + "subspace.RpcServerResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void RpcServerResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcServerResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.error_.ClearToEmpty(); + ::memset(&_impl_.client_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.request_id_) - + reinterpret_cast(&_impl_.client_id_)) + sizeof(_impl_.request_id_)); + clear_response(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcServerResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcServerResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcServerResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcServerResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcServerResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint64 client_id = 1; + if (this_._internal_client_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 1, this_._internal_client_id(), target); + } + + // int32 request_id = 2; + if (this_._internal_request_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_request_id(), target); + } + + switch (this_.response_case()) { + case kOpen: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.response_.open_, this_._impl_.response_.open_->GetCachedSize(), target, + stream); + break; + } + case kClose: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.response_.close_, this_._impl_.response_.close_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + // string error = 5; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcServerResponse.error"); + target = stream->WriteStringMaybeAliased(5, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcServerResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcServerResponse::ByteSizeLong(const MessageLite& base) { + const RpcServerResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcServerResponse::ByteSizeLong() const { + const RpcServerResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcServerResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string error = 5; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + // uint64 client_id = 1; + if (this_._internal_client_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_client_id()); + } + // int32 request_id = 2; + if (this_._internal_request_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_request_id()); + } + } + switch (this_.response_case()) { + // .subspace.RpcOpenResponse open = 3; + case kOpen: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.open_); + break; + } + // .subspace.RpcCloseResponse close = 4; + case kClose: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_.close_); + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcServerResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcServerResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + if (from._internal_client_id() != 0) { + _this->_impl_.client_id_ = from._impl_.client_id_; + } + if (from._internal_request_id() != 0) { + _this->_impl_.request_id_ = from._impl_.request_id_; + } + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_response(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kOpen: { + if (oneof_needs_init) { + _this->_impl_.response_.open_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RpcOpenResponse>(arena, *from._impl_.response_.open_); + } else { + _this->_impl_.response_.open_->MergeFrom(from._internal_open()); + } + break; + } + case kClose: { + if (oneof_needs_init) { + _this->_impl_.response_.close_ = + ::google::protobuf::Message::CopyConstruct<::subspace::RpcCloseResponse>(arena, *from._impl_.response_.close_); + } else { + _this->_impl_.response_.close_->MergeFrom(from._internal_close()); + } + break; + } + case RESPONSE_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcServerResponse::CopyFrom(const RpcServerResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcServerResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcServerResponse::InternalSwap(RpcServerResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.request_id_) + + sizeof(RpcServerResponse::_impl_.request_id_) + - PROTOBUF_FIELD_OFFSET(RpcServerResponse, _impl_.client_id_)>( + reinterpret_cast(&_impl_.client_id_), + reinterpret_cast(&other->_impl_.client_id_)); + swap(_impl_.response_, other->_impl_.response_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::google::protobuf::Metadata RpcServerResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_._has_bits_); +}; + +void RpcRequest::clear_argument() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.argument_ != nullptr) _impl_.argument_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +RpcRequest::RpcRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcRequest) +} +inline PROTOBUF_NDEBUG_INLINE RpcRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +RpcRequest::RpcRequest( + ::google::protobuf::Arena* arena, + const RpcRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.argument_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::google::protobuf::Any>( + arena, *from._impl_.argument_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, method_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, method_), + offsetof(Impl_, request_id_) - + offsetof(Impl_, method_) + + sizeof(Impl_::request_id_)); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcRequest) +} +inline PROTOBUF_NDEBUG_INLINE RpcRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RpcRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, argument_), + 0, + offsetof(Impl_, request_id_) - + offsetof(Impl_, argument_) + + sizeof(Impl_::request_id_)); +} +RpcRequest::~RpcRequest() { + // @@protoc_insertion_point(destructor:subspace.RpcRequest) + SharedDtor(*this); +} +inline void RpcRequest::SharedDtor(MessageLite& self) { + RpcRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.argument_; + this_._impl_.~Impl_(); +} + +inline void* RpcRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcRequest(arena); +} +constexpr auto RpcRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RpcRequest), + alignof(RpcRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcRequest::ByteSizeLong, + &RpcRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_._cached_size_), + false, + }, + &RpcRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 1, 0, 2> RpcRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_._has_bits_), + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 method = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcRequest, _impl_.method_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.method_)}}, + // .google.protobuf.Any argument = 2; + {::_pbi::TcParser::FastMtS1, + {18, 0, 0, PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.argument_)}}, + // int32 session_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcRequest, _impl_.session_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.session_id_)}}, + // int32 request_id = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcRequest, _impl_.request_id_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.request_id_)}}, + // uint64 client_id = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RpcRequest, _impl_.client_id_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.client_id_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 method = 1; + {PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.method_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // .google.protobuf.Any argument = 2; + {PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.argument_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // int32 session_id = 3; + {PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.session_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 request_id = 4; + {PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.request_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint64 client_id = 5; + {PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.client_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + }}, {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void RpcRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.argument_ != nullptr); + _impl_.argument_->Clear(); + } + ::memset(&_impl_.method_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.request_id_) - + reinterpret_cast(&_impl_.method_)) + sizeof(_impl_.request_id_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 method = 1; + if (this_._internal_method() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this_._internal_method(), target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .google.protobuf.Any argument = 2; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.argument_, this_._impl_.argument_->GetCachedSize(), target, + stream); + } + + // int32 session_id = 3; + if (this_._internal_session_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_session_id(), target); + } + + // int32 request_id = 4; + if (this_._internal_request_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_request_id(), target); + } + + // uint64 client_id = 5; + if (this_._internal_client_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 5, this_._internal_client_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcRequest::ByteSizeLong(const MessageLite& base) { + const RpcRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcRequest::ByteSizeLong() const { + const RpcRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // .google.protobuf.Any argument = 2; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.argument_); + } + } + { + // int32 method = 1; + if (this_._internal_method() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_method()); + } + // int32 session_id = 3; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_session_id()); + } + // uint64 client_id = 5; + if (this_._internal_client_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_client_id()); + } + // int32 request_id = 4; + if (this_._internal_request_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_request_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.argument_ != nullptr); + if (_this->_impl_.argument_ == nullptr) { + _this->_impl_.argument_ = + ::google::protobuf::Message::CopyConstruct<::google::protobuf::Any>(arena, *from._impl_.argument_); + } else { + _this->_impl_.argument_->MergeFrom(*from._impl_.argument_); + } + } + if (from._internal_method() != 0) { + _this->_impl_.method_ = from._impl_.method_; + } + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_client_id() != 0) { + _this->_impl_.client_id_ = from._impl_.client_id_; + } + if (from._internal_request_id() != 0) { + _this->_impl_.request_id_ = from._impl_.request_id_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcRequest::CopyFrom(const RpcRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcRequest::InternalSwap(RpcRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.request_id_) + + sizeof(RpcRequest::_impl_.request_id_) + - PROTOBUF_FIELD_OFFSET(RpcRequest, _impl_.argument_)>( + reinterpret_cast(&_impl_.argument_), + reinterpret_cast(&other->_impl_.argument_)); +} + +::google::protobuf::Metadata RpcRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcResponse::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_._has_bits_); +}; + +void RpcResponse::clear_result() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.result_ != nullptr) _impl_.result_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +RpcResponse::RpcResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcResponse) +} +inline PROTOBUF_NDEBUG_INLINE RpcResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RpcResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + error_(arena, from.error_) {} + +RpcResponse::RpcResponse( + ::google::protobuf::Arena* arena, + const RpcResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RpcResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.result_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::google::protobuf::Any>( + arena, *from._impl_.result_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, session_id_), + offsetof(Impl_, is_cancelled_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::is_cancelled_)); + + // @@protoc_insertion_point(copy_constructor:subspace.RpcResponse) +} +inline PROTOBUF_NDEBUG_INLINE RpcResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + error_(arena) {} + +inline void RpcResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, result_), + 0, + offsetof(Impl_, is_cancelled_) - + offsetof(Impl_, result_) + + sizeof(Impl_::is_cancelled_)); +} +RpcResponse::~RpcResponse() { + // @@protoc_insertion_point(destructor:subspace.RpcResponse) + SharedDtor(*this); +} +inline void RpcResponse::SharedDtor(MessageLite& self) { + RpcResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.error_.Destroy(); + delete this_._impl_.result_; + this_._impl_.~Impl_(); +} + +inline void* RpcResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcResponse(arena); +} +constexpr auto RpcResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcResponse), + alignof(RpcResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcResponse::ByteSizeLong, + &RpcResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_._cached_size_), + false, + }, + &RpcResponse::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 1, 34, 2> RpcResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_._has_bits_), + 0, // no _extensions_ + 7, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967168, // skipmap + offsetof(decltype(_table_), field_entries), + 7, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string error = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.error_)}}, + // .google.protobuf.Any result = 2; + {::_pbi::TcParser::FastMtS1, + {18, 0, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.result_)}}, + // int32 session_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcResponse, _impl_.session_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.session_id_)}}, + // int32 request_id = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcResponse, _impl_.request_id_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.request_id_)}}, + // uint64 client_id = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RpcResponse, _impl_.client_id_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.client_id_)}}, + // bool is_last = 6; + {::_pbi::TcParser::SingularVarintNoZag1(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.is_last_)}}, + // bool is_cancelled = 7; + {::_pbi::TcParser::SingularVarintNoZag1(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.is_cancelled_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string error = 1; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.error_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .google.protobuf.Any result = 2; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.result_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // int32 session_id = 3; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.session_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 request_id = 4; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.request_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint64 client_id = 5; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.client_id_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // bool is_last = 6; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.is_last_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_cancelled = 7; + {PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.is_cancelled_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + }}, {{ + "\24\5\0\0\0\0\0\0" + "subspace.RpcResponse" + "error" + }}, +}; + +PROTOBUF_NOINLINE void RpcResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.error_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.result_ != nullptr); + _impl_.result_->Clear(); + } + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.is_cancelled_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.is_cancelled_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string error = 1; + if (!this_._internal_error().empty()) { + const std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.RpcResponse.error"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .google.protobuf.Any result = 2; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.result_, this_._impl_.result_->GetCachedSize(), target, + stream); + } + + // int32 session_id = 3; + if (this_._internal_session_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_session_id(), target); + } + + // int32 request_id = 4; + if (this_._internal_request_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_request_id(), target); + } + + // uint64 client_id = 5; + if (this_._internal_client_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 5, this_._internal_client_id(), target); + } + + // bool is_last = 6; + if (this_._internal_is_last() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_is_last(), target); + } + + // bool is_cancelled = 7; + if (this_._internal_is_cancelled() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 7, this_._internal_is_cancelled(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcResponse::ByteSizeLong(const MessageLite& base) { + const RpcResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcResponse::ByteSizeLong() const { + const RpcResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string error = 1; + if (!this_._internal_error().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); + } + } + { + // .google.protobuf.Any result = 2; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_); + } + } + { + // int32 session_id = 3; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_session_id()); + } + // int32 request_id = 4; + if (this_._internal_request_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_request_id()); + } + // uint64 client_id = 5; + if (this_._internal_client_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_client_id()); + } + // bool is_last = 6; + if (this_._internal_is_last() != 0) { + total_size += 2; + } + // bool is_cancelled = 7; + if (this_._internal_is_cancelled() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_error().empty()) { + _this->_internal_set_error(from._internal_error()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.result_ != nullptr); + if (_this->_impl_.result_ == nullptr) { + _this->_impl_.result_ = + ::google::protobuf::Message::CopyConstruct<::google::protobuf::Any>(arena, *from._impl_.result_); + } else { + _this->_impl_.result_->MergeFrom(*from._impl_.result_); + } + } + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_request_id() != 0) { + _this->_impl_.request_id_ = from._impl_.request_id_; + } + if (from._internal_client_id() != 0) { + _this->_impl_.client_id_ = from._impl_.client_id_; + } + if (from._internal_is_last() != 0) { + _this->_impl_.is_last_ = from._impl_.is_last_; + } + if (from._internal_is_cancelled() != 0) { + _this->_impl_.is_cancelled_ = from._impl_.is_cancelled_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcResponse::CopyFrom(const RpcResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcResponse::InternalSwap(RpcResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.is_cancelled_) + + sizeof(RpcResponse::_impl_.is_cancelled_) + - PROTOBUF_FIELD_OFFSET(RpcResponse, _impl_.result_)>( + reinterpret_cast(&_impl_.result_), + reinterpret_cast(&other->_impl_.result_)); +} + +::google::protobuf::Metadata RpcResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RpcCancelRequest::_Internal { + public: +}; + +RpcCancelRequest::RpcCancelRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RpcCancelRequest) +} +RpcCancelRequest::RpcCancelRequest( + ::google::protobuf::Arena* arena, const RpcCancelRequest& from) + : RpcCancelRequest(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE RpcCancelRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RpcCancelRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + 0, + offsetof(Impl_, client_id_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::client_id_)); +} +RpcCancelRequest::~RpcCancelRequest() { + // @@protoc_insertion_point(destructor:subspace.RpcCancelRequest) + SharedDtor(*this); +} +inline void RpcCancelRequest::SharedDtor(MessageLite& self) { + RpcCancelRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* RpcCancelRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RpcCancelRequest(arena); +} +constexpr auto RpcCancelRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RpcCancelRequest), + alignof(RpcCancelRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RpcCancelRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RpcCancelRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcCancelRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcCancelRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RpcCancelRequest::ByteSizeLong, + &RpcCancelRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_._cached_size_), + false, + }, + &RpcCancelRequest::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RpcCancelRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 0, 2> RpcCancelRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RpcCancelRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int32 session_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcCancelRequest, _impl_.session_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.session_id_)}}, + // int32 request_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RpcCancelRequest, _impl_.request_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.request_id_)}}, + // uint64 client_id = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RpcCancelRequest, _impl_.client_id_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.client_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int32 session_id = 1; + {PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 request_id = 2; + {PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.request_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // uint64 client_id = 3; + {PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.client_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void RpcCancelRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RpcCancelRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.client_id_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.client_id_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RpcCancelRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RpcCancelRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RpcCancelRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RpcCancelRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RpcCancelRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 session_id = 1; + if (this_._internal_session_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<1>( + stream, this_._internal_session_id(), target); + } + + // int32 request_id = 2; + if (this_._internal_request_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_request_id(), target); + } + + // uint64 client_id = 3; + if (this_._internal_client_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 3, this_._internal_client_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RpcCancelRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RpcCancelRequest::ByteSizeLong(const MessageLite& base) { + const RpcCancelRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RpcCancelRequest::ByteSizeLong() const { + const RpcCancelRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RpcCancelRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // int32 session_id = 1; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_session_id()); + } + // int32 request_id = 2; + if (this_._internal_request_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_request_id()); + } + // uint64 client_id = 3; + if (this_._internal_client_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_client_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RpcCancelRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RpcCancelRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_request_id() != 0) { + _this->_impl_.request_id_ = from._impl_.request_id_; + } + if (from._internal_client_id() != 0) { + _this->_impl_.client_id_ = from._impl_.client_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RpcCancelRequest::CopyFrom(const RpcCancelRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RpcCancelRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RpcCancelRequest::InternalSwap(RpcCancelRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.client_id_) + + sizeof(RpcCancelRequest::_impl_.client_id_) + - PROTOBUF_FIELD_OFFSET(RpcCancelRequest, _impl_.session_id_)>( + reinterpret_cast(&_impl_.session_id_), + reinterpret_cast(&other->_impl_.session_id_)); +} + +::google::protobuf::Metadata RpcCancelRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RawMessage::_Internal { + public: +}; + +RawMessage::RawMessage(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.RawMessage) +} +inline PROTOBUF_NDEBUG_INLINE RawMessage::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::RawMessage& from_msg) + : data_(arena, from.data_), + _cached_size_{0} {} + +RawMessage::RawMessage( + ::google::protobuf::Arena* arena, + const RawMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RawMessage* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:subspace.RawMessage) +} +inline PROTOBUF_NDEBUG_INLINE RawMessage::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : data_(arena), + _cached_size_{0} {} + +inline void RawMessage::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +RawMessage::~RawMessage() { + // @@protoc_insertion_point(destructor:subspace.RawMessage) + SharedDtor(*this); +} +inline void RawMessage::SharedDtor(MessageLite& self) { + RawMessage& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.data_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RawMessage::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RawMessage(arena); +} +constexpr auto RawMessage::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RawMessage), + alignof(RawMessage)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RawMessage::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RawMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RawMessage::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RawMessage::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RawMessage::ByteSizeLong, + &RawMessage::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RawMessage, _impl_._cached_size_), + false, + }, + &RawMessage::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RawMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RawMessage::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::RawMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bytes data = 1; + {::_pbi::TcParser::FastBS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RawMessage, _impl_.data_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes data = 1; + {PROTOBUF_FIELD_OFFSET(RawMessage, _impl_.data_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void RawMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.RawMessage) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.data_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RawMessage::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RawMessage& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RawMessage::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RawMessage& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.RawMessage) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // bytes data = 1; + if (!this_._internal_data().empty()) { + const std::string& _s = this_._internal_data(); + target = stream->WriteBytesMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.RawMessage) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RawMessage::ByteSizeLong(const MessageLite& base) { + const RawMessage& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RawMessage::ByteSizeLong() const { + const RawMessage& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.RawMessage) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // bytes data = 1; + if (!this_._internal_data().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_data()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RawMessage::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.RawMessage) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_data().empty()) { + _this->_internal_set_data(from._internal_data()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RawMessage::CopyFrom(const RawMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.RawMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RawMessage::InternalSwap(RawMessage* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); +} + +::google::protobuf::Metadata RawMessage::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class VoidMessage::_Internal { + public: +}; + +VoidMessage::VoidMessage(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:subspace.VoidMessage) +} +VoidMessage::VoidMessage( + ::google::protobuf::Arena* arena, + const VoidMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + VoidMessage* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:subspace.VoidMessage) +} + +inline void* VoidMessage::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) VoidMessage(arena); +} +constexpr auto VoidMessage::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(VoidMessage), + alignof(VoidMessage)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull VoidMessage::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_VoidMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &VoidMessage::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &VoidMessage::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &VoidMessage::ByteSizeLong, + &VoidMessage::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(VoidMessage, _impl_._cached_size_), + false, + }, + &VoidMessage::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* VoidMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> VoidMessage::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::VoidMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata VoidMessage::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowEvent::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::subspace::ShadowEvent, _impl_._oneof_case_); +}; + +void ShadowEvent::set_allocated_init(::subspace::ShadowInit* init) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (init) { + ::google::protobuf::Arena* submessage_arena = init->GetArena(); + if (message_arena != submessage_arena) { + init = ::google::protobuf::internal::GetOwnedMessage(message_arena, init, submessage_arena); + } + set_has_init(); + _impl_.event_.init_ = init; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.init) +} +void ShadowEvent::set_allocated_create_channel(::subspace::ShadowCreateChannel* create_channel) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (create_channel) { + ::google::protobuf::Arena* submessage_arena = create_channel->GetArena(); + if (message_arena != submessage_arena) { + create_channel = ::google::protobuf::internal::GetOwnedMessage(message_arena, create_channel, submessage_arena); + } + set_has_create_channel(); + _impl_.event_.create_channel_ = create_channel; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.create_channel) +} +void ShadowEvent::set_allocated_remove_channel(::subspace::ShadowRemoveChannel* remove_channel) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (remove_channel) { + ::google::protobuf::Arena* submessage_arena = remove_channel->GetArena(); + if (message_arena != submessage_arena) { + remove_channel = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_channel, submessage_arena); + } + set_has_remove_channel(); + _impl_.event_.remove_channel_ = remove_channel; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.remove_channel) +} +void ShadowEvent::set_allocated_add_publisher(::subspace::ShadowAddPublisher* add_publisher) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (add_publisher) { + ::google::protobuf::Arena* submessage_arena = add_publisher->GetArena(); + if (message_arena != submessage_arena) { + add_publisher = ::google::protobuf::internal::GetOwnedMessage(message_arena, add_publisher, submessage_arena); + } + set_has_add_publisher(); + _impl_.event_.add_publisher_ = add_publisher; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.add_publisher) +} +void ShadowEvent::set_allocated_remove_publisher(::subspace::ShadowRemovePublisher* remove_publisher) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (remove_publisher) { + ::google::protobuf::Arena* submessage_arena = remove_publisher->GetArena(); + if (message_arena != submessage_arena) { + remove_publisher = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_publisher, submessage_arena); + } + set_has_remove_publisher(); + _impl_.event_.remove_publisher_ = remove_publisher; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.remove_publisher) +} +void ShadowEvent::set_allocated_add_subscriber(::subspace::ShadowAddSubscriber* add_subscriber) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (add_subscriber) { + ::google::protobuf::Arena* submessage_arena = add_subscriber->GetArena(); + if (message_arena != submessage_arena) { + add_subscriber = ::google::protobuf::internal::GetOwnedMessage(message_arena, add_subscriber, submessage_arena); + } + set_has_add_subscriber(); + _impl_.event_.add_subscriber_ = add_subscriber; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.add_subscriber) +} +void ShadowEvent::set_allocated_remove_subscriber(::subspace::ShadowRemoveSubscriber* remove_subscriber) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (remove_subscriber) { + ::google::protobuf::Arena* submessage_arena = remove_subscriber->GetArena(); + if (message_arena != submessage_arena) { + remove_subscriber = ::google::protobuf::internal::GetOwnedMessage(message_arena, remove_subscriber, submessage_arena); + } + set_has_remove_subscriber(); + _impl_.event_.remove_subscriber_ = remove_subscriber; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.remove_subscriber) +} +void ShadowEvent::set_allocated_state_dump(::subspace::ShadowStateDump* state_dump) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (state_dump) { + ::google::protobuf::Arena* submessage_arena = state_dump->GetArena(); + if (message_arena != submessage_arena) { + state_dump = ::google::protobuf::internal::GetOwnedMessage(message_arena, state_dump, submessage_arena); + } + set_has_state_dump(); + _impl_.event_.state_dump_ = state_dump; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.state_dump) +} +void ShadowEvent::set_allocated_state_done(::subspace::ShadowStateDone* state_done) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (state_done) { + ::google::protobuf::Arena* submessage_arena = state_done->GetArena(); + if (message_arena != submessage_arena) { + state_done = ::google::protobuf::internal::GetOwnedMessage(message_arena, state_done, submessage_arena); + } + set_has_state_done(); + _impl_.event_.state_done_ = state_done; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.state_done) +} +void ShadowEvent::set_allocated_register_client_buffer(::subspace::ShadowRegisterClientBuffer* register_client_buffer) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (register_client_buffer) { + ::google::protobuf::Arena* submessage_arena = register_client_buffer->GetArena(); + if (message_arena != submessage_arena) { + register_client_buffer = ::google::protobuf::internal::GetOwnedMessage(message_arena, register_client_buffer, submessage_arena); + } + set_has_register_client_buffer(); + _impl_.event_.register_client_buffer_ = register_client_buffer; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.register_client_buffer) +} +void ShadowEvent::set_allocated_unregister_client_buffer(::subspace::ShadowUnregisterClientBuffer* unregister_client_buffer) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (unregister_client_buffer) { + ::google::protobuf::Arena* submessage_arena = unregister_client_buffer->GetArena(); + if (message_arena != submessage_arena) { + unregister_client_buffer = ::google::protobuf::internal::GetOwnedMessage(message_arena, unregister_client_buffer, submessage_arena); + } + set_has_unregister_client_buffer(); + _impl_.event_.unregister_client_buffer_ = unregister_client_buffer; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.unregister_client_buffer) +} +void ShadowEvent::set_allocated_update_channel_options(::subspace::ShadowUpdateChannelOptions* update_channel_options) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_event(); + if (update_channel_options) { + ::google::protobuf::Arena* submessage_arena = update_channel_options->GetArena(); + if (message_arena != submessage_arena) { + update_channel_options = ::google::protobuf::internal::GetOwnedMessage(message_arena, update_channel_options, submessage_arena); + } + set_has_update_channel_options(); + _impl_.event_.update_channel_options_ = update_channel_options; + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowEvent.update_channel_options) +} +ShadowEvent::ShadowEvent(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowEvent) +} +inline PROTOBUF_NDEBUG_INLINE ShadowEvent::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowEvent& from_msg) + : event_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +ShadowEvent::ShadowEvent( + ::google::protobuf::Arena* arena, + const ShadowEvent& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowEvent* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + switch (event_case()) { + case EVENT_NOT_SET: + break; + case kInit: + _impl_.event_.init_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowInit>(arena, *from._impl_.event_.init_); + break; + case kCreateChannel: + _impl_.event_.create_channel_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowCreateChannel>(arena, *from._impl_.event_.create_channel_); + break; + case kRemoveChannel: + _impl_.event_.remove_channel_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRemoveChannel>(arena, *from._impl_.event_.remove_channel_); + break; + case kAddPublisher: + _impl_.event_.add_publisher_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowAddPublisher>(arena, *from._impl_.event_.add_publisher_); + break; + case kRemovePublisher: + _impl_.event_.remove_publisher_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRemovePublisher>(arena, *from._impl_.event_.remove_publisher_); + break; + case kAddSubscriber: + _impl_.event_.add_subscriber_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowAddSubscriber>(arena, *from._impl_.event_.add_subscriber_); + break; + case kRemoveSubscriber: + _impl_.event_.remove_subscriber_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRemoveSubscriber>(arena, *from._impl_.event_.remove_subscriber_); + break; + case kStateDump: + _impl_.event_.state_dump_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowStateDump>(arena, *from._impl_.event_.state_dump_); + break; + case kStateDone: + _impl_.event_.state_done_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowStateDone>(arena, *from._impl_.event_.state_done_); + break; + case kRegisterClientBuffer: + _impl_.event_.register_client_buffer_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRegisterClientBuffer>(arena, *from._impl_.event_.register_client_buffer_); + break; + case kUnregisterClientBuffer: + _impl_.event_.unregister_client_buffer_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowUnregisterClientBuffer>(arena, *from._impl_.event_.unregister_client_buffer_); + break; + case kUpdateChannelOptions: + _impl_.event_.update_channel_options_ = ::google::protobuf::Message::CopyConstruct<::subspace::ShadowUpdateChannelOptions>(arena, *from._impl_.event_.update_channel_options_); + break; + } + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowEvent) +} +inline PROTOBUF_NDEBUG_INLINE ShadowEvent::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : event_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void ShadowEvent::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ShadowEvent::~ShadowEvent() { + // @@protoc_insertion_point(destructor:subspace.ShadowEvent) + SharedDtor(*this); +} +inline void ShadowEvent::SharedDtor(MessageLite& self) { + ShadowEvent& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + if (this_.has_event()) { + this_.clear_event(); + } + this_._impl_.~Impl_(); +} + +void ShadowEvent::clear_event() { +// @@protoc_insertion_point(one_of_clear_start:subspace.ShadowEvent) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (event_case()) { + case kInit: { + if (GetArena() == nullptr) { + delete _impl_.event_.init_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.init_); + } + break; + } + case kCreateChannel: { + if (GetArena() == nullptr) { + delete _impl_.event_.create_channel_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.create_channel_); + } + break; + } + case kRemoveChannel: { + if (GetArena() == nullptr) { + delete _impl_.event_.remove_channel_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.remove_channel_); + } + break; + } + case kAddPublisher: { + if (GetArena() == nullptr) { + delete _impl_.event_.add_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.add_publisher_); + } + break; + } + case kRemovePublisher: { + if (GetArena() == nullptr) { + delete _impl_.event_.remove_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.remove_publisher_); + } + break; + } + case kAddSubscriber: { + if (GetArena() == nullptr) { + delete _impl_.event_.add_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.add_subscriber_); + } + break; + } + case kRemoveSubscriber: { + if (GetArena() == nullptr) { + delete _impl_.event_.remove_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.remove_subscriber_); + } + break; + } + case kStateDump: { + if (GetArena() == nullptr) { + delete _impl_.event_.state_dump_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.state_dump_); + } + break; + } + case kStateDone: { + if (GetArena() == nullptr) { + delete _impl_.event_.state_done_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.state_done_); + } + break; + } + case kRegisterClientBuffer: { + if (GetArena() == nullptr) { + delete _impl_.event_.register_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.register_client_buffer_); + } + break; + } + case kUnregisterClientBuffer: { + if (GetArena() == nullptr) { + delete _impl_.event_.unregister_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.unregister_client_buffer_); + } + break; + } + case kUpdateChannelOptions: { + if (GetArena() == nullptr) { + delete _impl_.event_.update_channel_options_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.update_channel_options_); + } + break; + } + case EVENT_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = EVENT_NOT_SET; +} + + +inline void* ShadowEvent::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowEvent(arena); +} +constexpr auto ShadowEvent::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ShadowEvent), + alignof(ShadowEvent)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowEvent::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowEvent_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowEvent::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowEvent::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowEvent::ByteSizeLong, + &ShadowEvent::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_._cached_size_), + false, + }, + &ShadowEvent::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowEvent::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 12, 12, 0, 2> ShadowEvent::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 12, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294963200, // skipmap + offsetof(decltype(_table_), field_entries), + 12, // num_field_entries + 12, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowEvent>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .subspace.ShadowInit init = 1; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.init_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowCreateChannel create_channel = 2; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.create_channel_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowRemoveChannel remove_channel = 3; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.remove_channel_), _Internal::kOneofCaseOffset + 0, 2, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowAddPublisher add_publisher = 4; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.add_publisher_), _Internal::kOneofCaseOffset + 0, 3, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowRemovePublisher remove_publisher = 5; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.remove_publisher_), _Internal::kOneofCaseOffset + 0, 4, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowAddSubscriber add_subscriber = 6; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.add_subscriber_), _Internal::kOneofCaseOffset + 0, 5, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowRemoveSubscriber remove_subscriber = 7; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.remove_subscriber_), _Internal::kOneofCaseOffset + 0, 6, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowStateDump state_dump = 8; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.state_dump_), _Internal::kOneofCaseOffset + 0, 7, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowStateDone state_done = 9; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.state_done_), _Internal::kOneofCaseOffset + 0, 8, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowRegisterClientBuffer register_client_buffer = 10; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.register_client_buffer_), _Internal::kOneofCaseOffset + 0, 9, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowUnregisterClientBuffer unregister_client_buffer = 11; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.unregister_client_buffer_), _Internal::kOneofCaseOffset + 0, 10, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .subspace.ShadowUpdateChannelOptions update_channel_options = 12; + {PROTOBUF_FIELD_OFFSET(ShadowEvent, _impl_.event_.update_channel_options_), _Internal::kOneofCaseOffset + 0, 11, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ShadowInit>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowCreateChannel>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowRemoveChannel>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowAddPublisher>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowRemovePublisher>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowAddSubscriber>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowRemoveSubscriber>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowStateDump>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowStateDone>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowRegisterClientBuffer>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowUnregisterClientBuffer>()}, + {::_pbi::TcParser::GetTable<::subspace::ShadowUpdateChannelOptions>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void ShadowEvent::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowEvent) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_event(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowEvent::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowEvent& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowEvent::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowEvent& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowEvent) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (this_.event_case()) { + case kInit: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.event_.init_, this_._impl_.event_.init_->GetCachedSize(), target, + stream); + break; + } + case kCreateChannel: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.event_.create_channel_, this_._impl_.event_.create_channel_->GetCachedSize(), target, + stream); + break; + } + case kRemoveChannel: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.event_.remove_channel_, this_._impl_.event_.remove_channel_->GetCachedSize(), target, + stream); + break; + } + case kAddPublisher: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.event_.add_publisher_, this_._impl_.event_.add_publisher_->GetCachedSize(), target, + stream); + break; + } + case kRemovePublisher: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 5, *this_._impl_.event_.remove_publisher_, this_._impl_.event_.remove_publisher_->GetCachedSize(), target, + stream); + break; + } + case kAddSubscriber: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 6, *this_._impl_.event_.add_subscriber_, this_._impl_.event_.add_subscriber_->GetCachedSize(), target, + stream); + break; + } + case kRemoveSubscriber: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 7, *this_._impl_.event_.remove_subscriber_, this_._impl_.event_.remove_subscriber_->GetCachedSize(), target, + stream); + break; + } + case kStateDump: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 8, *this_._impl_.event_.state_dump_, this_._impl_.event_.state_dump_->GetCachedSize(), target, + stream); + break; + } + case kStateDone: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 9, *this_._impl_.event_.state_done_, this_._impl_.event_.state_done_->GetCachedSize(), target, + stream); + break; + } + case kRegisterClientBuffer: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 10, *this_._impl_.event_.register_client_buffer_, this_._impl_.event_.register_client_buffer_->GetCachedSize(), target, + stream); + break; + } + case kUnregisterClientBuffer: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 11, *this_._impl_.event_.unregister_client_buffer_, this_._impl_.event_.unregister_client_buffer_->GetCachedSize(), target, + stream); + break; + } + case kUpdateChannelOptions: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 12, *this_._impl_.event_.update_channel_options_, this_._impl_.event_.update_channel_options_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowEvent) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowEvent::ByteSizeLong(const MessageLite& base) { + const ShadowEvent& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowEvent::ByteSizeLong() const { + const ShadowEvent& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowEvent) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (this_.event_case()) { + // .subspace.ShadowInit init = 1; + case kInit: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.init_); + break; + } + // .subspace.ShadowCreateChannel create_channel = 2; + case kCreateChannel: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.create_channel_); + break; + } + // .subspace.ShadowRemoveChannel remove_channel = 3; + case kRemoveChannel: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.remove_channel_); + break; + } + // .subspace.ShadowAddPublisher add_publisher = 4; + case kAddPublisher: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.add_publisher_); + break; + } + // .subspace.ShadowRemovePublisher remove_publisher = 5; + case kRemovePublisher: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.remove_publisher_); + break; + } + // .subspace.ShadowAddSubscriber add_subscriber = 6; + case kAddSubscriber: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.add_subscriber_); + break; + } + // .subspace.ShadowRemoveSubscriber remove_subscriber = 7; + case kRemoveSubscriber: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.remove_subscriber_); + break; + } + // .subspace.ShadowStateDump state_dump = 8; + case kStateDump: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.state_dump_); + break; + } + // .subspace.ShadowStateDone state_done = 9; + case kStateDone: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.state_done_); + break; + } + // .subspace.ShadowRegisterClientBuffer register_client_buffer = 10; + case kRegisterClientBuffer: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.register_client_buffer_); + break; + } + // .subspace.ShadowUnregisterClientBuffer unregister_client_buffer = 11; + case kUnregisterClientBuffer: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.unregister_client_buffer_); + break; + } + // .subspace.ShadowUpdateChannelOptions update_channel_options = 12; + case kUpdateChannelOptions: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.event_.update_channel_options_); + break; + } + case EVENT_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowEvent::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowEvent) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_event(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kInit: { + if (oneof_needs_init) { + _this->_impl_.event_.init_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowInit>(arena, *from._impl_.event_.init_); + } else { + _this->_impl_.event_.init_->MergeFrom(from._internal_init()); + } + break; + } + case kCreateChannel: { + if (oneof_needs_init) { + _this->_impl_.event_.create_channel_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowCreateChannel>(arena, *from._impl_.event_.create_channel_); + } else { + _this->_impl_.event_.create_channel_->MergeFrom(from._internal_create_channel()); + } + break; + } + case kRemoveChannel: { + if (oneof_needs_init) { + _this->_impl_.event_.remove_channel_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRemoveChannel>(arena, *from._impl_.event_.remove_channel_); + } else { + _this->_impl_.event_.remove_channel_->MergeFrom(from._internal_remove_channel()); + } + break; + } + case kAddPublisher: { + if (oneof_needs_init) { + _this->_impl_.event_.add_publisher_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowAddPublisher>(arena, *from._impl_.event_.add_publisher_); + } else { + _this->_impl_.event_.add_publisher_->MergeFrom(from._internal_add_publisher()); + } + break; + } + case kRemovePublisher: { + if (oneof_needs_init) { + _this->_impl_.event_.remove_publisher_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRemovePublisher>(arena, *from._impl_.event_.remove_publisher_); + } else { + _this->_impl_.event_.remove_publisher_->MergeFrom(from._internal_remove_publisher()); + } + break; + } + case kAddSubscriber: { + if (oneof_needs_init) { + _this->_impl_.event_.add_subscriber_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowAddSubscriber>(arena, *from._impl_.event_.add_subscriber_); + } else { + _this->_impl_.event_.add_subscriber_->MergeFrom(from._internal_add_subscriber()); + } + break; + } + case kRemoveSubscriber: { + if (oneof_needs_init) { + _this->_impl_.event_.remove_subscriber_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRemoveSubscriber>(arena, *from._impl_.event_.remove_subscriber_); + } else { + _this->_impl_.event_.remove_subscriber_->MergeFrom(from._internal_remove_subscriber()); + } + break; + } + case kStateDump: { + if (oneof_needs_init) { + _this->_impl_.event_.state_dump_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowStateDump>(arena, *from._impl_.event_.state_dump_); + } else { + _this->_impl_.event_.state_dump_->MergeFrom(from._internal_state_dump()); + } + break; + } + case kStateDone: { + if (oneof_needs_init) { + _this->_impl_.event_.state_done_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowStateDone>(arena, *from._impl_.event_.state_done_); + } else { + _this->_impl_.event_.state_done_->MergeFrom(from._internal_state_done()); + } + break; + } + case kRegisterClientBuffer: { + if (oneof_needs_init) { + _this->_impl_.event_.register_client_buffer_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowRegisterClientBuffer>(arena, *from._impl_.event_.register_client_buffer_); + } else { + _this->_impl_.event_.register_client_buffer_->MergeFrom(from._internal_register_client_buffer()); + } + break; + } + case kUnregisterClientBuffer: { + if (oneof_needs_init) { + _this->_impl_.event_.unregister_client_buffer_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowUnregisterClientBuffer>(arena, *from._impl_.event_.unregister_client_buffer_); + } else { + _this->_impl_.event_.unregister_client_buffer_->MergeFrom(from._internal_unregister_client_buffer()); + } + break; + } + case kUpdateChannelOptions: { + if (oneof_needs_init) { + _this->_impl_.event_.update_channel_options_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ShadowUpdateChannelOptions>(arena, *from._impl_.event_.update_channel_options_); + } else { + _this->_impl_.event_.update_channel_options_->MergeFrom(from._internal_update_channel_options()); + } + break; + } + case EVENT_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowEvent::CopyFrom(const ShadowEvent& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowEvent) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowEvent::InternalSwap(ShadowEvent* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.event_, other->_impl_.event_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::google::protobuf::Metadata ShadowEvent::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowInit::_Internal { + public: +}; + +ShadowInit::ShadowInit(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowInit) +} +ShadowInit::ShadowInit( + ::google::protobuf::Arena* arena, const ShadowInit& from) + : ShadowInit(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ShadowInit::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ShadowInit::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.session_id_ = {}; +} +ShadowInit::~ShadowInit() { + // @@protoc_insertion_point(destructor:subspace.ShadowInit) + SharedDtor(*this); +} +inline void ShadowInit::SharedDtor(MessageLite& self) { + ShadowInit& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ShadowInit::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowInit(arena); +} +constexpr auto ShadowInit::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ShadowInit), + alignof(ShadowInit)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowInit::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowInit_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowInit::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowInit::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowInit::ByteSizeLong, + &ShadowInit::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowInit, _impl_._cached_size_), + false, + }, + &ShadowInit::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowInit::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> ShadowInit::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowInit>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint64 session_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ShadowInit, _impl_.session_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowInit, _impl_.session_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint64 session_id = 1; + {PROTOBUF_FIELD_OFFSET(ShadowInit, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ShadowInit::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowInit) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.session_id_ = ::uint64_t{0u}; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowInit::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowInit& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowInit::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowInit& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowInit) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint64 session_id = 1; + if (this_._internal_session_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 1, this_._internal_session_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowInit) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowInit::ByteSizeLong(const MessageLite& base) { + const ShadowInit& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowInit::ByteSizeLong() const { + const ShadowInit& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowInit) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint64 session_id = 1; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_session_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowInit::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowInit) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowInit::CopyFrom(const ShadowInit& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowInit) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowInit::InternalSwap(ShadowInit* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.session_id_, other->_impl_.session_id_); +} + +::google::protobuf::Metadata ShadowInit::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowCreateChannel::_Internal { + public: +}; + +ShadowCreateChannel::ShadowCreateChannel(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowCreateChannel) +} +inline PROTOBUF_NDEBUG_INLINE ShadowCreateChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowCreateChannel& from_msg) + : channel_name_(arena, from.channel_name_), + type_(arena, from.type_), + mux_(arena, from.mux_), + _cached_size_{0} {} + +ShadowCreateChannel::ShadowCreateChannel( + ::google::protobuf::Arena* arena, + const ShadowCreateChannel& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowCreateChannel* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, channel_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, channel_id_), + offsetof(Impl_, max_publishers_) - + offsetof(Impl_, channel_id_) + + sizeof(Impl_::max_publishers_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowCreateChannel) +} +inline PROTOBUF_NDEBUG_INLINE ShadowCreateChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + type_(arena), + mux_(arena), + _cached_size_{0} {} + +inline void ShadowCreateChannel::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, channel_id_), + 0, + offsetof(Impl_, max_publishers_) - + offsetof(Impl_, channel_id_) + + sizeof(Impl_::max_publishers_)); +} +ShadowCreateChannel::~ShadowCreateChannel() { + // @@protoc_insertion_point(destructor:subspace.ShadowCreateChannel) + SharedDtor(*this); +} +inline void ShadowCreateChannel::SharedDtor(MessageLite& self) { + ShadowCreateChannel& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.type_.Destroy(); + this_._impl_.mux_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowCreateChannel::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowCreateChannel(arena); +} +constexpr auto ShadowCreateChannel::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowCreateChannel), + alignof(ShadowCreateChannel)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowCreateChannel::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowCreateChannel_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowCreateChannel::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowCreateChannel::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowCreateChannel::ByteSizeLong, + &ShadowCreateChannel::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_._cached_size_), + false, + }, + &ShadowCreateChannel::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowCreateChannel::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<5, 17, 0, 68, 2> ShadowCreateChannel::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 17, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294836224, // skipmap + offsetof(decltype(_table_), field_entries), + 17, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowCreateChannel>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.channel_name_)}}, + // int32 channel_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowCreateChannel, _impl_.channel_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.channel_id_)}}, + // int32 slot_size = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowCreateChannel, _impl_.slot_size_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.slot_size_)}}, + // int32 num_slots = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowCreateChannel, _impl_.num_slots_), 63>(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.num_slots_)}}, + // bytes type = 5; + {::_pbi::TcParser::FastBS1, + {42, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.type_)}}, + // bool is_local = 6; + {::_pbi::TcParser::SingularVarintNoZag1(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.is_local_)}}, + // bool is_reliable = 7; + {::_pbi::TcParser::SingularVarintNoZag1(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.is_reliable_)}}, + // bool is_fixed_size = 8; + {::_pbi::TcParser::SingularVarintNoZag1(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.is_fixed_size_)}}, + // int32 checksum_size = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowCreateChannel, _impl_.checksum_size_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.checksum_size_)}}, + // int32 metadata_size = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowCreateChannel, _impl_.metadata_size_), 63>(), + {80, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.metadata_size_)}}, + // string mux = 11; + {::_pbi::TcParser::FastUS1, + {90, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.mux_)}}, + // int32 vchan_id = 12; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowCreateChannel, _impl_.vchan_id_), 63>(), + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.vchan_id_)}}, + // bool has_split_buffer_options = 13; + {::_pbi::TcParser::SingularVarintNoZag1(), + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.has_split_buffer_options_)}}, + // bool use_split_buffers = 14; + {::_pbi::TcParser::SingularVarintNoZag1(), + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.use_split_buffers_)}}, + // bool has_max_publishers = 15; + {::_pbi::TcParser::SingularVarintNoZag1(), + {120, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.has_max_publishers_)}}, + // int32 max_publishers = 16; + {::_pbi::TcParser::FastV32S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.max_publishers_)}}, + // bool split_buffers_over_bridge = 17; + {::_pbi::TcParser::FastV8S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.split_buffers_over_bridge_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 channel_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.channel_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 slot_size = 3; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.slot_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 num_slots = 4; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.num_slots_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bytes type = 5; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, + // bool is_local = 6; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.is_local_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_reliable = 7; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.is_reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_fixed_size = 8; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.is_fixed_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 checksum_size = 9; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.checksum_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // int32 metadata_size = 10; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.metadata_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // string mux = 11; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.mux_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 vchan_id = 12; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.vchan_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool has_split_buffer_options = 13; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.has_split_buffer_options_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool use_split_buffers = 14; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.use_split_buffers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool has_max_publishers = 15; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.has_max_publishers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 max_publishers = 16; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.max_publishers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool split_buffers_over_bridge = 17; + {PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.split_buffers_over_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\34\14\0\0\0\0\0\0\0\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.ShadowCreateChannel" + "channel_name" + "mux" + }}, +}; + +PROTOBUF_NOINLINE void ShadowCreateChannel::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowCreateChannel) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.type_.ClearToEmpty(); + _impl_.mux_.ClearToEmpty(); + ::memset(&_impl_.channel_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.max_publishers_) - + reinterpret_cast(&_impl_.channel_id_)) + sizeof(_impl_.max_publishers_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowCreateChannel::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowCreateChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowCreateChannel::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowCreateChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowCreateChannel) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowCreateChannel.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_channel_id(), target); + } + + // int32 slot_size = 3; + if (this_._internal_slot_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<3>( + stream, this_._internal_slot_size(), target); + } + + // int32 num_slots = 4; + if (this_._internal_num_slots() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<4>( + stream, this_._internal_num_slots(), target); + } + + // bytes type = 5; + if (!this_._internal_type().empty()) { + const std::string& _s = this_._internal_type(); + target = stream->WriteBytesMaybeAliased(5, _s, target); + } + + // bool is_local = 6; + if (this_._internal_is_local() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_is_local(), target); + } + + // bool is_reliable = 7; + if (this_._internal_is_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 7, this_._internal_is_reliable(), target); + } + + // bool is_fixed_size = 8; + if (this_._internal_is_fixed_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 8, this_._internal_is_fixed_size(), target); + } + + // int32 checksum_size = 9; + if (this_._internal_checksum_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<9>( + stream, this_._internal_checksum_size(), target); + } + + // int32 metadata_size = 10; + if (this_._internal_metadata_size() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<10>( + stream, this_._internal_metadata_size(), target); + } + + // string mux = 11; + if (!this_._internal_mux().empty()) { + const std::string& _s = this_._internal_mux(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowCreateChannel.mux"); + target = stream->WriteStringMaybeAliased(11, _s, target); + } + + // int32 vchan_id = 12; + if (this_._internal_vchan_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<12>( + stream, this_._internal_vchan_id(), target); + } + + // bool has_split_buffer_options = 13; + if (this_._internal_has_split_buffer_options() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 13, this_._internal_has_split_buffer_options(), target); + } + + // bool use_split_buffers = 14; + if (this_._internal_use_split_buffers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 14, this_._internal_use_split_buffers(), target); + } + + // bool has_max_publishers = 15; + if (this_._internal_has_max_publishers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 15, this_._internal_has_max_publishers(), target); + } + + // int32 max_publishers = 16; + if (this_._internal_max_publishers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 16, this_._internal_max_publishers(), target); + } + + // bool split_buffers_over_bridge = 17; + if (this_._internal_split_buffers_over_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 17, this_._internal_split_buffers_over_bridge(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowCreateChannel) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowCreateChannel::ByteSizeLong(const MessageLite& base) { + const ShadowCreateChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowCreateChannel::ByteSizeLong() const { + const ShadowCreateChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowCreateChannel) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // bytes type = 5; + if (!this_._internal_type().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_type()); + } + // string mux = 11; + if (!this_._internal_mux().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_mux()); + } + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_channel_id()); + } + // int32 slot_size = 3; + if (this_._internal_slot_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_slot_size()); + } + // int32 num_slots = 4; + if (this_._internal_num_slots() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_slots()); + } + // bool is_local = 6; + if (this_._internal_is_local() != 0) { + total_size += 2; + } + // bool is_reliable = 7; + if (this_._internal_is_reliable() != 0) { + total_size += 2; + } + // bool is_fixed_size = 8; + if (this_._internal_is_fixed_size() != 0) { + total_size += 2; + } + // bool has_split_buffer_options = 13; + if (this_._internal_has_split_buffer_options() != 0) { + total_size += 2; + } + // int32 checksum_size = 9; + if (this_._internal_checksum_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_checksum_size()); + } + // int32 metadata_size = 10; + if (this_._internal_metadata_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_metadata_size()); + } + // int32 vchan_id = 12; + if (this_._internal_vchan_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_vchan_id()); + } + // bool use_split_buffers = 14; + if (this_._internal_use_split_buffers() != 0) { + total_size += 2; + } + // bool has_max_publishers = 15; + if (this_._internal_has_max_publishers() != 0) { + total_size += 2; + } + // bool split_buffers_over_bridge = 17; + if (this_._internal_split_buffers_over_bridge() != 0) { + total_size += 3; + } + // int32 max_publishers = 16; + if (this_._internal_max_publishers() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::Int32Size( + this_._internal_max_publishers()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowCreateChannel::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowCreateChannel) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (!from._internal_type().empty()) { + _this->_internal_set_type(from._internal_type()); + } + if (!from._internal_mux().empty()) { + _this->_internal_set_mux(from._internal_mux()); + } + if (from._internal_channel_id() != 0) { + _this->_impl_.channel_id_ = from._impl_.channel_id_; + } + if (from._internal_slot_size() != 0) { + _this->_impl_.slot_size_ = from._impl_.slot_size_; + } + if (from._internal_num_slots() != 0) { + _this->_impl_.num_slots_ = from._impl_.num_slots_; + } + if (from._internal_is_local() != 0) { + _this->_impl_.is_local_ = from._impl_.is_local_; + } + if (from._internal_is_reliable() != 0) { + _this->_impl_.is_reliable_ = from._impl_.is_reliable_; + } + if (from._internal_is_fixed_size() != 0) { + _this->_impl_.is_fixed_size_ = from._impl_.is_fixed_size_; + } + if (from._internal_has_split_buffer_options() != 0) { + _this->_impl_.has_split_buffer_options_ = from._impl_.has_split_buffer_options_; + } + if (from._internal_checksum_size() != 0) { + _this->_impl_.checksum_size_ = from._impl_.checksum_size_; + } + if (from._internal_metadata_size() != 0) { + _this->_impl_.metadata_size_ = from._impl_.metadata_size_; + } + if (from._internal_vchan_id() != 0) { + _this->_impl_.vchan_id_ = from._impl_.vchan_id_; + } + if (from._internal_use_split_buffers() != 0) { + _this->_impl_.use_split_buffers_ = from._impl_.use_split_buffers_; + } + if (from._internal_has_max_publishers() != 0) { + _this->_impl_.has_max_publishers_ = from._impl_.has_max_publishers_; + } + if (from._internal_split_buffers_over_bridge() != 0) { + _this->_impl_.split_buffers_over_bridge_ = from._impl_.split_buffers_over_bridge_; + } + if (from._internal_max_publishers() != 0) { + _this->_impl_.max_publishers_ = from._impl_.max_publishers_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowCreateChannel::CopyFrom(const ShadowCreateChannel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowCreateChannel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowCreateChannel::InternalSwap(ShadowCreateChannel* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.type_, &other->_impl_.type_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.mux_, &other->_impl_.mux_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.max_publishers_) + + sizeof(ShadowCreateChannel::_impl_.max_publishers_) + - PROTOBUF_FIELD_OFFSET(ShadowCreateChannel, _impl_.channel_id_)>( + reinterpret_cast(&_impl_.channel_id_), + reinterpret_cast(&other->_impl_.channel_id_)); +} + +::google::protobuf::Metadata ShadowCreateChannel::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowRemoveChannel::_Internal { + public: +}; + +ShadowRemoveChannel::ShadowRemoveChannel(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowRemoveChannel) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRemoveChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowRemoveChannel& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowRemoveChannel::ShadowRemoveChannel( + ::google::protobuf::Arena* arena, + const ShadowRemoveChannel& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowRemoveChannel* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.channel_id_ = from._impl_.channel_id_; + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowRemoveChannel) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRemoveChannel::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowRemoveChannel::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.channel_id_ = {}; +} +ShadowRemoveChannel::~ShadowRemoveChannel() { + // @@protoc_insertion_point(destructor:subspace.ShadowRemoveChannel) + SharedDtor(*this); +} +inline void ShadowRemoveChannel::SharedDtor(MessageLite& self) { + ShadowRemoveChannel& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowRemoveChannel::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowRemoveChannel(arena); +} +constexpr auto ShadowRemoveChannel::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowRemoveChannel), + alignof(ShadowRemoveChannel)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowRemoveChannel::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowRemoveChannel_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowRemoveChannel::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowRemoveChannel::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowRemoveChannel::ByteSizeLong, + &ShadowRemoveChannel::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowRemoveChannel, _impl_._cached_size_), + false, + }, + &ShadowRemoveChannel::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowRemoveChannel::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 49, 2> ShadowRemoveChannel::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowRemoveChannel>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 channel_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowRemoveChannel, _impl_.channel_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowRemoveChannel, _impl_.channel_id_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowRemoveChannel, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowRemoveChannel, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 channel_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowRemoveChannel, _impl_.channel_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\34\14\0\0\0\0\0\0" + "subspace.ShadowRemoveChannel" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowRemoveChannel::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowRemoveChannel) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.channel_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowRemoveChannel::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowRemoveChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowRemoveChannel::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowRemoveChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowRemoveChannel) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowRemoveChannel.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_channel_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowRemoveChannel) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowRemoveChannel::ByteSizeLong(const MessageLite& base) { + const ShadowRemoveChannel& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowRemoveChannel::ByteSizeLong() const { + const ShadowRemoveChannel& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowRemoveChannel) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 channel_id = 2; + if (this_._internal_channel_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_channel_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowRemoveChannel::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowRemoveChannel) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_channel_id() != 0) { + _this->_impl_.channel_id_ = from._impl_.channel_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowRemoveChannel::CopyFrom(const ShadowRemoveChannel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowRemoveChannel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowRemoveChannel::InternalSwap(ShadowRemoveChannel* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + swap(_impl_.channel_id_, other->_impl_.channel_id_); +} + +::google::protobuf::Metadata ShadowRemoveChannel::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowAddPublisher::_Internal { + public: +}; + +ShadowAddPublisher::ShadowAddPublisher(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowAddPublisher) +} +inline PROTOBUF_NDEBUG_INLINE ShadowAddPublisher::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowAddPublisher& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowAddPublisher::ShadowAddPublisher( + ::google::protobuf::Arena* arena, + const ShadowAddPublisher& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowAddPublisher* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, publisher_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, publisher_id_), + offsetof(Impl_, for_tunnel_) - + offsetof(Impl_, publisher_id_) + + sizeof(Impl_::for_tunnel_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowAddPublisher) +} +inline PROTOBUF_NDEBUG_INLINE ShadowAddPublisher::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowAddPublisher::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, publisher_id_), + 0, + offsetof(Impl_, for_tunnel_) - + offsetof(Impl_, publisher_id_) + + sizeof(Impl_::for_tunnel_)); +} +ShadowAddPublisher::~ShadowAddPublisher() { + // @@protoc_insertion_point(destructor:subspace.ShadowAddPublisher) + SharedDtor(*this); +} +inline void ShadowAddPublisher::SharedDtor(MessageLite& self) { + ShadowAddPublisher& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowAddPublisher::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowAddPublisher(arena); +} +constexpr auto ShadowAddPublisher::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowAddPublisher), + alignof(ShadowAddPublisher)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowAddPublisher::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowAddPublisher_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowAddPublisher::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowAddPublisher::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowAddPublisher::ByteSizeLong, + &ShadowAddPublisher::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_._cached_size_), + false, + }, + &ShadowAddPublisher::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowAddPublisher::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 8, 0, 56, 2> ShadowAddPublisher::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 8, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967040, // skipmap + offsetof(decltype(_table_), field_entries), + 8, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowAddPublisher>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool for_tunnel = 8; + {::_pbi::TcParser::SingularVarintNoZag1(), + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.for_tunnel_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.channel_name_)}}, + // int32 publisher_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowAddPublisher, _impl_.publisher_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.publisher_id_)}}, + // bool is_reliable = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_reliable_)}}, + // bool is_local = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_local_)}}, + // bool is_bridge = 5; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_bridge_)}}, + // bool is_fixed_size = 6; + {::_pbi::TcParser::SingularVarintNoZag1(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_fixed_size_)}}, + // bool notify_retirement = 7; + {::_pbi::TcParser::SingularVarintNoZag1(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.notify_retirement_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 publisher_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.publisher_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool is_reliable = 3; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_local = 4; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_local_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_bridge = 5; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_fixed_size = 6; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.is_fixed_size_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool notify_retirement = 7; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.notify_retirement_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool for_tunnel = 8; + {PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.for_tunnel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\33\14\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "subspace.ShadowAddPublisher" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowAddPublisher::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowAddPublisher) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.publisher_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.for_tunnel_) - + reinterpret_cast(&_impl_.publisher_id_)) + sizeof(_impl_.for_tunnel_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowAddPublisher::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowAddPublisher& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowAddPublisher::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowAddPublisher& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowAddPublisher) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowAddPublisher.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 publisher_id = 2; + if (this_._internal_publisher_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_publisher_id(), target); + } + + // bool is_reliable = 3; + if (this_._internal_is_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_is_reliable(), target); + } + + // bool is_local = 4; + if (this_._internal_is_local() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_is_local(), target); + } + + // bool is_bridge = 5; + if (this_._internal_is_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_is_bridge(), target); + } + + // bool is_fixed_size = 6; + if (this_._internal_is_fixed_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_is_fixed_size(), target); + } + + // bool notify_retirement = 7; + if (this_._internal_notify_retirement() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 7, this_._internal_notify_retirement(), target); + } + + // bool for_tunnel = 8; + if (this_._internal_for_tunnel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 8, this_._internal_for_tunnel(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowAddPublisher) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowAddPublisher::ByteSizeLong(const MessageLite& base) { + const ShadowAddPublisher& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowAddPublisher::ByteSizeLong() const { + const ShadowAddPublisher& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowAddPublisher) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 publisher_id = 2; + if (this_._internal_publisher_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_publisher_id()); + } + // bool is_reliable = 3; + if (this_._internal_is_reliable() != 0) { + total_size += 2; + } + // bool is_local = 4; + if (this_._internal_is_local() != 0) { + total_size += 2; + } + // bool is_bridge = 5; + if (this_._internal_is_bridge() != 0) { + total_size += 2; + } + // bool is_fixed_size = 6; + if (this_._internal_is_fixed_size() != 0) { + total_size += 2; + } + // bool notify_retirement = 7; + if (this_._internal_notify_retirement() != 0) { + total_size += 2; + } + // bool for_tunnel = 8; + if (this_._internal_for_tunnel() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowAddPublisher::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowAddPublisher) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_publisher_id() != 0) { + _this->_impl_.publisher_id_ = from._impl_.publisher_id_; + } + if (from._internal_is_reliable() != 0) { + _this->_impl_.is_reliable_ = from._impl_.is_reliable_; + } + if (from._internal_is_local() != 0) { + _this->_impl_.is_local_ = from._impl_.is_local_; + } + if (from._internal_is_bridge() != 0) { + _this->_impl_.is_bridge_ = from._impl_.is_bridge_; + } + if (from._internal_is_fixed_size() != 0) { + _this->_impl_.is_fixed_size_ = from._impl_.is_fixed_size_; + } + if (from._internal_notify_retirement() != 0) { + _this->_impl_.notify_retirement_ = from._impl_.notify_retirement_; + } + if (from._internal_for_tunnel() != 0) { + _this->_impl_.for_tunnel_ = from._impl_.for_tunnel_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowAddPublisher::CopyFrom(const ShadowAddPublisher& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowAddPublisher) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowAddPublisher::InternalSwap(ShadowAddPublisher* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.for_tunnel_) + + sizeof(ShadowAddPublisher::_impl_.for_tunnel_) + - PROTOBUF_FIELD_OFFSET(ShadowAddPublisher, _impl_.publisher_id_)>( + reinterpret_cast(&_impl_.publisher_id_), + reinterpret_cast(&other->_impl_.publisher_id_)); +} + +::google::protobuf::Metadata ShadowAddPublisher::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowRemovePublisher::_Internal { + public: +}; + +ShadowRemovePublisher::ShadowRemovePublisher(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowRemovePublisher) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRemovePublisher::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowRemovePublisher& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowRemovePublisher::ShadowRemovePublisher( + ::google::protobuf::Arena* arena, + const ShadowRemovePublisher& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowRemovePublisher* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.publisher_id_ = from._impl_.publisher_id_; + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowRemovePublisher) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRemovePublisher::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowRemovePublisher::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.publisher_id_ = {}; +} +ShadowRemovePublisher::~ShadowRemovePublisher() { + // @@protoc_insertion_point(destructor:subspace.ShadowRemovePublisher) + SharedDtor(*this); +} +inline void ShadowRemovePublisher::SharedDtor(MessageLite& self) { + ShadowRemovePublisher& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowRemovePublisher::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowRemovePublisher(arena); +} +constexpr auto ShadowRemovePublisher::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowRemovePublisher), + alignof(ShadowRemovePublisher)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowRemovePublisher::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowRemovePublisher_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowRemovePublisher::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowRemovePublisher::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowRemovePublisher::ByteSizeLong, + &ShadowRemovePublisher::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowRemovePublisher, _impl_._cached_size_), + false, + }, + &ShadowRemovePublisher::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowRemovePublisher::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 51, 2> ShadowRemovePublisher::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowRemovePublisher>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 publisher_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowRemovePublisher, _impl_.publisher_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowRemovePublisher, _impl_.publisher_id_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowRemovePublisher, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowRemovePublisher, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 publisher_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowRemovePublisher, _impl_.publisher_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\36\14\0\0\0\0\0\0" + "subspace.ShadowRemovePublisher" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowRemovePublisher::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowRemovePublisher) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.publisher_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowRemovePublisher::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowRemovePublisher& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowRemovePublisher::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowRemovePublisher& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowRemovePublisher) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowRemovePublisher.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 publisher_id = 2; + if (this_._internal_publisher_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_publisher_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowRemovePublisher) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowRemovePublisher::ByteSizeLong(const MessageLite& base) { + const ShadowRemovePublisher& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowRemovePublisher::ByteSizeLong() const { + const ShadowRemovePublisher& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowRemovePublisher) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 publisher_id = 2; + if (this_._internal_publisher_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_publisher_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowRemovePublisher::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowRemovePublisher) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_publisher_id() != 0) { + _this->_impl_.publisher_id_ = from._impl_.publisher_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowRemovePublisher::CopyFrom(const ShadowRemovePublisher& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowRemovePublisher) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowRemovePublisher::InternalSwap(ShadowRemovePublisher* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + swap(_impl_.publisher_id_, other->_impl_.publisher_id_); +} + +::google::protobuf::Metadata ShadowRemovePublisher::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowAddSubscriber::_Internal { + public: +}; + +ShadowAddSubscriber::ShadowAddSubscriber(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowAddSubscriber) +} +inline PROTOBUF_NDEBUG_INLINE ShadowAddSubscriber::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowAddSubscriber& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowAddSubscriber::ShadowAddSubscriber( + ::google::protobuf::Arena* arena, + const ShadowAddSubscriber& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowAddSubscriber* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, subscriber_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, subscriber_id_), + offsetof(Impl_, max_active_messages_) - + offsetof(Impl_, subscriber_id_) + + sizeof(Impl_::max_active_messages_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowAddSubscriber) +} +inline PROTOBUF_NDEBUG_INLINE ShadowAddSubscriber::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowAddSubscriber::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, subscriber_id_), + 0, + offsetof(Impl_, max_active_messages_) - + offsetof(Impl_, subscriber_id_) + + sizeof(Impl_::max_active_messages_)); +} +ShadowAddSubscriber::~ShadowAddSubscriber() { + // @@protoc_insertion_point(destructor:subspace.ShadowAddSubscriber) + SharedDtor(*this); +} +inline void ShadowAddSubscriber::SharedDtor(MessageLite& self) { + ShadowAddSubscriber& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowAddSubscriber::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowAddSubscriber(arena); +} +constexpr auto ShadowAddSubscriber::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowAddSubscriber), + alignof(ShadowAddSubscriber)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowAddSubscriber::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowAddSubscriber_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowAddSubscriber::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowAddSubscriber::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowAddSubscriber::ByteSizeLong, + &ShadowAddSubscriber::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_._cached_size_), + false, + }, + &ShadowAddSubscriber::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowAddSubscriber::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 6, 0, 49, 2> ShadowAddSubscriber::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 6, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967232, // skipmap + offsetof(decltype(_table_), field_entries), + 6, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowAddSubscriber>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.channel_name_)}}, + // int32 subscriber_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowAddSubscriber, _impl_.subscriber_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.subscriber_id_)}}, + // bool is_reliable = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.is_reliable_)}}, + // bool is_bridge = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.is_bridge_)}}, + // int32 max_active_messages = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowAddSubscriber, _impl_.max_active_messages_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.max_active_messages_)}}, + // bool for_tunnel = 6; + {::_pbi::TcParser::SingularVarintNoZag1(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.for_tunnel_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 subscriber_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.subscriber_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool is_reliable = 3; + {PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.is_reliable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_bridge = 4; + {PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.is_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 max_active_messages = 5; + {PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.max_active_messages_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool for_tunnel = 6; + {PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.for_tunnel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\34\14\0\0\0\0\0\0" + "subspace.ShadowAddSubscriber" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowAddSubscriber::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowAddSubscriber) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.subscriber_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.max_active_messages_) - + reinterpret_cast(&_impl_.subscriber_id_)) + sizeof(_impl_.max_active_messages_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowAddSubscriber::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowAddSubscriber& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowAddSubscriber::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowAddSubscriber& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowAddSubscriber) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowAddSubscriber.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_subscriber_id(), target); + } + + // bool is_reliable = 3; + if (this_._internal_is_reliable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_is_reliable(), target); + } + + // bool is_bridge = 4; + if (this_._internal_is_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_is_bridge(), target); + } + + // int32 max_active_messages = 5; + if (this_._internal_max_active_messages() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this_._internal_max_active_messages(), target); + } + + // bool for_tunnel = 6; + if (this_._internal_for_tunnel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_for_tunnel(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowAddSubscriber) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowAddSubscriber::ByteSizeLong(const MessageLite& base) { + const ShadowAddSubscriber& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowAddSubscriber::ByteSizeLong() const { + const ShadowAddSubscriber& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowAddSubscriber) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_subscriber_id()); + } + // bool is_reliable = 3; + if (this_._internal_is_reliable() != 0) { + total_size += 2; + } + // bool is_bridge = 4; + if (this_._internal_is_bridge() != 0) { + total_size += 2; + } + // bool for_tunnel = 6; + if (this_._internal_for_tunnel() != 0) { + total_size += 2; + } + // int32 max_active_messages = 5; + if (this_._internal_max_active_messages() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_max_active_messages()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowAddSubscriber::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowAddSubscriber) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_subscriber_id() != 0) { + _this->_impl_.subscriber_id_ = from._impl_.subscriber_id_; + } + if (from._internal_is_reliable() != 0) { + _this->_impl_.is_reliable_ = from._impl_.is_reliable_; + } + if (from._internal_is_bridge() != 0) { + _this->_impl_.is_bridge_ = from._impl_.is_bridge_; + } + if (from._internal_for_tunnel() != 0) { + _this->_impl_.for_tunnel_ = from._impl_.for_tunnel_; + } + if (from._internal_max_active_messages() != 0) { + _this->_impl_.max_active_messages_ = from._impl_.max_active_messages_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowAddSubscriber::CopyFrom(const ShadowAddSubscriber& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowAddSubscriber) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowAddSubscriber::InternalSwap(ShadowAddSubscriber* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.max_active_messages_) + + sizeof(ShadowAddSubscriber::_impl_.max_active_messages_) + - PROTOBUF_FIELD_OFFSET(ShadowAddSubscriber, _impl_.subscriber_id_)>( + reinterpret_cast(&_impl_.subscriber_id_), + reinterpret_cast(&other->_impl_.subscriber_id_)); +} + +::google::protobuf::Metadata ShadowAddSubscriber::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowRemoveSubscriber::_Internal { + public: +}; + +ShadowRemoveSubscriber::ShadowRemoveSubscriber(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowRemoveSubscriber) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRemoveSubscriber::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowRemoveSubscriber& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowRemoveSubscriber::ShadowRemoveSubscriber( + ::google::protobuf::Arena* arena, + const ShadowRemoveSubscriber& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowRemoveSubscriber* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.subscriber_id_ = from._impl_.subscriber_id_; + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowRemoveSubscriber) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRemoveSubscriber::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowRemoveSubscriber::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.subscriber_id_ = {}; +} +ShadowRemoveSubscriber::~ShadowRemoveSubscriber() { + // @@protoc_insertion_point(destructor:subspace.ShadowRemoveSubscriber) + SharedDtor(*this); +} +inline void ShadowRemoveSubscriber::SharedDtor(MessageLite& self) { + ShadowRemoveSubscriber& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowRemoveSubscriber::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowRemoveSubscriber(arena); +} +constexpr auto ShadowRemoveSubscriber::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowRemoveSubscriber), + alignof(ShadowRemoveSubscriber)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowRemoveSubscriber::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowRemoveSubscriber_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowRemoveSubscriber::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowRemoveSubscriber::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowRemoveSubscriber::ByteSizeLong, + &ShadowRemoveSubscriber::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowRemoveSubscriber, _impl_._cached_size_), + false, + }, + &ShadowRemoveSubscriber::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowRemoveSubscriber::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 52, 2> ShadowRemoveSubscriber::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowRemoveSubscriber>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 subscriber_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowRemoveSubscriber, _impl_.subscriber_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowRemoveSubscriber, _impl_.subscriber_id_)}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowRemoveSubscriber, _impl_.channel_name_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowRemoveSubscriber, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 subscriber_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowRemoveSubscriber, _impl_.subscriber_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\37\14\0\0\0\0\0\0" + "subspace.ShadowRemoveSubscriber" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowRemoveSubscriber::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowRemoveSubscriber) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + _impl_.subscriber_id_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowRemoveSubscriber::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowRemoveSubscriber& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowRemoveSubscriber::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowRemoveSubscriber& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowRemoveSubscriber) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowRemoveSubscriber.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_subscriber_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowRemoveSubscriber) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowRemoveSubscriber::ByteSizeLong(const MessageLite& base) { + const ShadowRemoveSubscriber& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowRemoveSubscriber::ByteSizeLong() const { + const ShadowRemoveSubscriber& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowRemoveSubscriber) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // int32 subscriber_id = 2; + if (this_._internal_subscriber_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_subscriber_id()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowRemoveSubscriber::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowRemoveSubscriber) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_subscriber_id() != 0) { + _this->_impl_.subscriber_id_ = from._impl_.subscriber_id_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowRemoveSubscriber::CopyFrom(const ShadowRemoveSubscriber& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowRemoveSubscriber) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowRemoveSubscriber::InternalSwap(ShadowRemoveSubscriber* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + swap(_impl_.subscriber_id_, other->_impl_.subscriber_id_); +} + +::google::protobuf::Metadata ShadowRemoveSubscriber::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowStateDump::_Internal { + public: +}; + +ShadowStateDump::ShadowStateDump(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowStateDump) +} +ShadowStateDump::ShadowStateDump( + ::google::protobuf::Arena* arena, const ShadowStateDump& from) + : ShadowStateDump(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ShadowStateDump::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ShadowStateDump::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + 0, + offsetof(Impl_, num_channels_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::num_channels_)); +} +ShadowStateDump::~ShadowStateDump() { + // @@protoc_insertion_point(destructor:subspace.ShadowStateDump) + SharedDtor(*this); +} +inline void ShadowStateDump::SharedDtor(MessageLite& self) { + ShadowStateDump& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ShadowStateDump::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowStateDump(arena); +} +constexpr auto ShadowStateDump::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ShadowStateDump), + alignof(ShadowStateDump)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowStateDump::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowStateDump_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowStateDump::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowStateDump::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowStateDump::ByteSizeLong, + &ShadowStateDump::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_._cached_size_), + false, + }, + &ShadowStateDump::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowStateDump::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> ShadowStateDump::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowStateDump>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 num_channels = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowStateDump, _impl_.num_channels_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_.num_channels_)}}, + // uint64 session_id = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ShadowStateDump, _impl_.session_id_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_.session_id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint64 session_id = 1; + {PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // int32 num_channels = 2; + {PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_.num_channels_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ShadowStateDump::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowStateDump) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.num_channels_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.num_channels_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowStateDump::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowStateDump& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowStateDump::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowStateDump& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowStateDump) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint64 session_id = 1; + if (this_._internal_session_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 1, this_._internal_session_id(), target); + } + + // int32 num_channels = 2; + if (this_._internal_num_channels() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<2>( + stream, this_._internal_num_channels(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowStateDump) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowStateDump::ByteSizeLong(const MessageLite& base) { + const ShadowStateDump& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowStateDump::ByteSizeLong() const { + const ShadowStateDump& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowStateDump) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint64 session_id = 1; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_session_id()); + } + // int32 num_channels = 2; + if (this_._internal_num_channels() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_num_channels()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowStateDump::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowStateDump) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_num_channels() != 0) { + _this->_impl_.num_channels_ = from._impl_.num_channels_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowStateDump::CopyFrom(const ShadowStateDump& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowStateDump) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowStateDump::InternalSwap(ShadowStateDump* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_.num_channels_) + + sizeof(ShadowStateDump::_impl_.num_channels_) + - PROTOBUF_FIELD_OFFSET(ShadowStateDump, _impl_.session_id_)>( + reinterpret_cast(&_impl_.session_id_), + reinterpret_cast(&other->_impl_.session_id_)); +} + +::google::protobuf::Metadata ShadowStateDump::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowStateDone::_Internal { + public: +}; + +ShadowStateDone::ShadowStateDone(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:subspace.ShadowStateDone) +} +ShadowStateDone::ShadowStateDone( + ::google::protobuf::Arena* arena, + const ShadowStateDone& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowStateDone* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowStateDone) +} + +inline void* ShadowStateDone::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowStateDone(arena); +} +constexpr auto ShadowStateDone::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ShadowStateDone), + alignof(ShadowStateDone)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowStateDone::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowStateDone_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowStateDone::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowStateDone::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &ShadowStateDone::ByteSizeLong, + &ShadowStateDone::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowStateDone, _impl_._cached_size_), + false, + }, + &ShadowStateDone::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowStateDone::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ShadowStateDone::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowStateDone>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata ShadowStateDone::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowRegisterClientBuffer::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ShadowRegisterClientBuffer, _impl_._has_bits_); +}; + +ShadowRegisterClientBuffer::ShadowRegisterClientBuffer(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowRegisterClientBuffer) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRegisterClientBuffer::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowRegisterClientBuffer& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +ShadowRegisterClientBuffer::ShadowRegisterClientBuffer( + ::google::protobuf::Arena* arena, + const ShadowRegisterClientBuffer& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowRegisterClientBuffer* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.metadata_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::subspace::ClientBufferHandleMetadataProto>( + arena, *from._impl_.metadata_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowRegisterClientBuffer) +} +inline PROTOBUF_NDEBUG_INLINE ShadowRegisterClientBuffer::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ShadowRegisterClientBuffer::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.metadata_ = {}; +} +ShadowRegisterClientBuffer::~ShadowRegisterClientBuffer() { + // @@protoc_insertion_point(destructor:subspace.ShadowRegisterClientBuffer) + SharedDtor(*this); +} +inline void ShadowRegisterClientBuffer::SharedDtor(MessageLite& self) { + ShadowRegisterClientBuffer& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.metadata_; + this_._impl_.~Impl_(); +} + +inline void* ShadowRegisterClientBuffer::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowRegisterClientBuffer(arena); +} +constexpr auto ShadowRegisterClientBuffer::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ShadowRegisterClientBuffer), + alignof(ShadowRegisterClientBuffer)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowRegisterClientBuffer::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowRegisterClientBuffer_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowRegisterClientBuffer::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowRegisterClientBuffer::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowRegisterClientBuffer::ByteSizeLong, + &ShadowRegisterClientBuffer::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowRegisterClientBuffer, _impl_._cached_size_), + false, + }, + &ShadowRegisterClientBuffer::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowRegisterClientBuffer::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> ShadowRegisterClientBuffer::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ShadowRegisterClientBuffer, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowRegisterClientBuffer>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(ShadowRegisterClientBuffer, _impl_.metadata_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + {PROTOBUF_FIELD_OFFSET(ShadowRegisterClientBuffer, _impl_.metadata_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::subspace::ClientBufferHandleMetadataProto>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void ShadowRegisterClientBuffer::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowRegisterClientBuffer) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.metadata_ != nullptr); + _impl_.metadata_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowRegisterClientBuffer::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowRegisterClientBuffer& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowRegisterClientBuffer::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowRegisterClientBuffer& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowRegisterClientBuffer) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.metadata_, this_._impl_.metadata_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowRegisterClientBuffer) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowRegisterClientBuffer::ByteSizeLong(const MessageLite& base) { + const ShadowRegisterClientBuffer& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowRegisterClientBuffer::ByteSizeLong() const { + const ShadowRegisterClientBuffer& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowRegisterClientBuffer) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.metadata_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowRegisterClientBuffer::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowRegisterClientBuffer) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.metadata_ != nullptr); + if (_this->_impl_.metadata_ == nullptr) { + _this->_impl_.metadata_ = + ::google::protobuf::Message::CopyConstruct<::subspace::ClientBufferHandleMetadataProto>(arena, *from._impl_.metadata_); + } else { + _this->_impl_.metadata_->MergeFrom(*from._impl_.metadata_); + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowRegisterClientBuffer::CopyFrom(const ShadowRegisterClientBuffer& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowRegisterClientBuffer) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowRegisterClientBuffer::InternalSwap(ShadowRegisterClientBuffer* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.metadata_, other->_impl_.metadata_); +} + +::google::protobuf::Metadata ShadowRegisterClientBuffer::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowUnregisterClientBuffer::_Internal { + public: +}; + +ShadowUnregisterClientBuffer::ShadowUnregisterClientBuffer(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowUnregisterClientBuffer) +} +inline PROTOBUF_NDEBUG_INLINE ShadowUnregisterClientBuffer::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowUnregisterClientBuffer& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowUnregisterClientBuffer::ShadowUnregisterClientBuffer( + ::google::protobuf::Arena* arena, + const ShadowUnregisterClientBuffer& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowUnregisterClientBuffer* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, session_id_), + offsetof(Impl_, buffer_index_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::buffer_index_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowUnregisterClientBuffer) +} +inline PROTOBUF_NDEBUG_INLINE ShadowUnregisterClientBuffer::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowUnregisterClientBuffer::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, session_id_), + 0, + offsetof(Impl_, buffer_index_) - + offsetof(Impl_, session_id_) + + sizeof(Impl_::buffer_index_)); +} +ShadowUnregisterClientBuffer::~ShadowUnregisterClientBuffer() { + // @@protoc_insertion_point(destructor:subspace.ShadowUnregisterClientBuffer) + SharedDtor(*this); +} +inline void ShadowUnregisterClientBuffer::SharedDtor(MessageLite& self) { + ShadowUnregisterClientBuffer& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowUnregisterClientBuffer::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowUnregisterClientBuffer(arena); +} +constexpr auto ShadowUnregisterClientBuffer::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowUnregisterClientBuffer), + alignof(ShadowUnregisterClientBuffer)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowUnregisterClientBuffer::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowUnregisterClientBuffer_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowUnregisterClientBuffer::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowUnregisterClientBuffer::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowUnregisterClientBuffer::ByteSizeLong, + &ShadowUnregisterClientBuffer::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_._cached_size_), + false, + }, + &ShadowUnregisterClientBuffer::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowUnregisterClientBuffer::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 58, 2> ShadowUnregisterClientBuffer::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowUnregisterClientBuffer>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.channel_name_)}}, + // uint64 session_id = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ShadowUnregisterClientBuffer, _impl_.session_id_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.session_id_)}}, + // uint32 buffer_index = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowUnregisterClientBuffer, _impl_.buffer_index_), 63>(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.buffer_index_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint64 session_id = 2; + {PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.session_id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint32 buffer_index = 3; + {PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.buffer_index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + "\45\14\0\0\0\0\0\0" + "subspace.ShadowUnregisterClientBuffer" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowUnregisterClientBuffer::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowUnregisterClientBuffer) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.session_id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.buffer_index_) - + reinterpret_cast(&_impl_.session_id_)) + sizeof(_impl_.buffer_index_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowUnregisterClientBuffer::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowUnregisterClientBuffer& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowUnregisterClientBuffer::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowUnregisterClientBuffer& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowUnregisterClientBuffer) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowUnregisterClientBuffer.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // uint64 session_id = 2; + if (this_._internal_session_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 2, this_._internal_session_id(), target); + } + + // uint32 buffer_index = 3; + if (this_._internal_buffer_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this_._internal_buffer_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowUnregisterClientBuffer) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowUnregisterClientBuffer::ByteSizeLong(const MessageLite& base) { + const ShadowUnregisterClientBuffer& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowUnregisterClientBuffer::ByteSizeLong() const { + const ShadowUnregisterClientBuffer& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowUnregisterClientBuffer) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // uint64 session_id = 2; + if (this_._internal_session_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_session_id()); + } + // uint32 buffer_index = 3; + if (this_._internal_buffer_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_buffer_index()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowUnregisterClientBuffer::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowUnregisterClientBuffer) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_session_id() != 0) { + _this->_impl_.session_id_ = from._impl_.session_id_; + } + if (from._internal_buffer_index() != 0) { + _this->_impl_.buffer_index_ = from._impl_.buffer_index_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowUnregisterClientBuffer::CopyFrom(const ShadowUnregisterClientBuffer& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowUnregisterClientBuffer) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowUnregisterClientBuffer::InternalSwap(ShadowUnregisterClientBuffer* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.buffer_index_) + + sizeof(ShadowUnregisterClientBuffer::_impl_.buffer_index_) + - PROTOBUF_FIELD_OFFSET(ShadowUnregisterClientBuffer, _impl_.session_id_)>( + reinterpret_cast(&_impl_.session_id_), + reinterpret_cast(&other->_impl_.session_id_)); +} + +::google::protobuf::Metadata ShadowUnregisterClientBuffer::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ShadowUpdateChannelOptions::_Internal { + public: +}; + +ShadowUpdateChannelOptions::ShadowUpdateChannelOptions(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:subspace.ShadowUpdateChannelOptions) +} +inline PROTOBUF_NDEBUG_INLINE ShadowUpdateChannelOptions::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::subspace::ShadowUpdateChannelOptions& from_msg) + : channel_name_(arena, from.channel_name_), + _cached_size_{0} {} + +ShadowUpdateChannelOptions::ShadowUpdateChannelOptions( + ::google::protobuf::Arena* arena, + const ShadowUpdateChannelOptions& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ShadowUpdateChannelOptions* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, has_split_buffer_options_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, has_split_buffer_options_), + offsetof(Impl_, max_publishers_) - + offsetof(Impl_, has_split_buffer_options_) + + sizeof(Impl_::max_publishers_)); + + // @@protoc_insertion_point(copy_constructor:subspace.ShadowUpdateChannelOptions) +} +inline PROTOBUF_NDEBUG_INLINE ShadowUpdateChannelOptions::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : channel_name_(arena), + _cached_size_{0} {} + +inline void ShadowUpdateChannelOptions::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, has_split_buffer_options_), + 0, + offsetof(Impl_, max_publishers_) - + offsetof(Impl_, has_split_buffer_options_) + + sizeof(Impl_::max_publishers_)); +} +ShadowUpdateChannelOptions::~ShadowUpdateChannelOptions() { + // @@protoc_insertion_point(destructor:subspace.ShadowUpdateChannelOptions) + SharedDtor(*this); +} +inline void ShadowUpdateChannelOptions::SharedDtor(MessageLite& self) { + ShadowUpdateChannelOptions& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.channel_name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ShadowUpdateChannelOptions::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ShadowUpdateChannelOptions(arena); +} +constexpr auto ShadowUpdateChannelOptions::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ShadowUpdateChannelOptions), + alignof(ShadowUpdateChannelOptions)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ShadowUpdateChannelOptions::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ShadowUpdateChannelOptions_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ShadowUpdateChannelOptions::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ShadowUpdateChannelOptions::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ShadowUpdateChannelOptions::ByteSizeLong, + &ShadowUpdateChannelOptions::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_._cached_size_), + false, + }, + &ShadowUpdateChannelOptions::kDescriptorMethods, + &descriptor_table_subspace_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ShadowUpdateChannelOptions::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 6, 0, 56, 2> ShadowUpdateChannelOptions::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 6, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967232, // skipmap + offsetof(decltype(_table_), field_entries), + 6, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::subspace::ShadowUpdateChannelOptions>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string channel_name = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.channel_name_)}}, + // bool has_split_buffer_options = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.has_split_buffer_options_)}}, + // bool use_split_buffers = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.use_split_buffers_)}}, + // bool has_max_publishers = 4; + {::_pbi::TcParser::SingularVarintNoZag1(), + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.has_max_publishers_)}}, + // int32 max_publishers = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ShadowUpdateChannelOptions, _impl_.max_publishers_), 63>(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.max_publishers_)}}, + // bool split_buffers_over_bridge = 6; + {::_pbi::TcParser::SingularVarintNoZag1(), + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.split_buffers_over_bridge_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string channel_name = 1; + {PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.channel_name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool has_split_buffer_options = 2; + {PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.has_split_buffer_options_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool use_split_buffers = 3; + {PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.use_split_buffers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool has_max_publishers = 4; + {PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.has_max_publishers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // int32 max_publishers = 5; + {PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.max_publishers_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, + // bool split_buffers_over_bridge = 6; + {PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.split_buffers_over_bridge_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\43\14\0\0\0\0\0\0" + "subspace.ShadowUpdateChannelOptions" + "channel_name" + }}, +}; + +PROTOBUF_NOINLINE void ShadowUpdateChannelOptions::Clear() { +// @@protoc_insertion_point(message_clear_start:subspace.ShadowUpdateChannelOptions) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.channel_name_.ClearToEmpty(); + ::memset(&_impl_.has_split_buffer_options_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.max_publishers_) - + reinterpret_cast(&_impl_.has_split_buffer_options_)) + sizeof(_impl_.max_publishers_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ShadowUpdateChannelOptions::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ShadowUpdateChannelOptions& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ShadowUpdateChannelOptions::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ShadowUpdateChannelOptions& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:subspace.ShadowUpdateChannelOptions) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + const std::string& _s = this_._internal_channel_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "subspace.ShadowUpdateChannelOptions.channel_name"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // bool has_split_buffer_options = 2; + if (this_._internal_has_split_buffer_options() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_has_split_buffer_options(), target); + } + + // bool use_split_buffers = 3; + if (this_._internal_use_split_buffers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_use_split_buffers(), target); + } + + // bool has_max_publishers = 4; + if (this_._internal_has_max_publishers() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_has_max_publishers(), target); + } + + // int32 max_publishers = 5; + if (this_._internal_max_publishers() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArrayWithField<5>( + stream, this_._internal_max_publishers(), target); + } + + // bool split_buffers_over_bridge = 6; + if (this_._internal_split_buffers_over_bridge() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_split_buffers_over_bridge(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:subspace.ShadowUpdateChannelOptions) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ShadowUpdateChannelOptions::ByteSizeLong(const MessageLite& base) { + const ShadowUpdateChannelOptions& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ShadowUpdateChannelOptions::ByteSizeLong() const { + const ShadowUpdateChannelOptions& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:subspace.ShadowUpdateChannelOptions) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string channel_name = 1; + if (!this_._internal_channel_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_channel_name()); + } + // bool has_split_buffer_options = 2; + if (this_._internal_has_split_buffer_options() != 0) { + total_size += 2; + } + // bool use_split_buffers = 3; + if (this_._internal_use_split_buffers() != 0) { + total_size += 2; + } + // bool has_max_publishers = 4; + if (this_._internal_has_max_publishers() != 0) { + total_size += 2; + } + // bool split_buffers_over_bridge = 6; + if (this_._internal_split_buffers_over_bridge() != 0) { + total_size += 2; + } + // int32 max_publishers = 5; + if (this_._internal_max_publishers() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_max_publishers()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ShadowUpdateChannelOptions::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:subspace.ShadowUpdateChannelOptions) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_channel_name().empty()) { + _this->_internal_set_channel_name(from._internal_channel_name()); + } + if (from._internal_has_split_buffer_options() != 0) { + _this->_impl_.has_split_buffer_options_ = from._impl_.has_split_buffer_options_; + } + if (from._internal_use_split_buffers() != 0) { + _this->_impl_.use_split_buffers_ = from._impl_.use_split_buffers_; + } + if (from._internal_has_max_publishers() != 0) { + _this->_impl_.has_max_publishers_ = from._impl_.has_max_publishers_; + } + if (from._internal_split_buffers_over_bridge() != 0) { + _this->_impl_.split_buffers_over_bridge_ = from._impl_.split_buffers_over_bridge_; + } + if (from._internal_max_publishers() != 0) { + _this->_impl_.max_publishers_ = from._impl_.max_publishers_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ShadowUpdateChannelOptions::CopyFrom(const ShadowUpdateChannelOptions& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:subspace.ShadowUpdateChannelOptions) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ShadowUpdateChannelOptions::InternalSwap(ShadowUpdateChannelOptions* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.channel_name_, &other->_impl_.channel_name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.max_publishers_) + + sizeof(ShadowUpdateChannelOptions::_impl_.max_publishers_) + - PROTOBUF_FIELD_OFFSET(ShadowUpdateChannelOptions, _impl_.has_split_buffer_options_)>( + reinterpret_cast(&_impl_.has_split_buffer_options_), + reinterpret_cast(&other->_impl_.has_split_buffer_options_)); +} + +::google::protobuf::Metadata ShadowUpdateChannelOptions::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace subspace +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_subspace_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/proto/subspace.pb.h b/proto/subspace.pb.h new file mode 100644 index 0000000..63e2aa2 --- /dev/null +++ b/proto/subspace.pb.h @@ -0,0 +1,25794 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: subspace.proto +// Protobuf C++ Version: 5.29.5 + +#ifndef subspace_2eproto_2epb_2eh +#define subspace_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029005 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_bases.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +#include "google/protobuf/any.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_subspace_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_subspace_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_subspace_2eproto; +namespace subspace { +class ChannelAddress; +struct ChannelAddressDefaultTypeInternal; +extern ChannelAddressDefaultTypeInternal _ChannelAddress_default_instance_; +class ChannelDirectory; +struct ChannelDirectoryDefaultTypeInternal; +extern ChannelDirectoryDefaultTypeInternal _ChannelDirectory_default_instance_; +class ChannelInfoProto; +struct ChannelInfoProtoDefaultTypeInternal; +extern ChannelInfoProtoDefaultTypeInternal _ChannelInfoProto_default_instance_; +class ChannelStatsProto; +struct ChannelStatsProtoDefaultTypeInternal; +extern ChannelStatsProtoDefaultTypeInternal _ChannelStatsProto_default_instance_; +class ClientBufferHandleMetadataProto; +struct ClientBufferHandleMetadataProtoDefaultTypeInternal; +extern ClientBufferHandleMetadataProtoDefaultTypeInternal _ClientBufferHandleMetadataProto_default_instance_; +class CreatePublisherRequest; +struct CreatePublisherRequestDefaultTypeInternal; +extern CreatePublisherRequestDefaultTypeInternal _CreatePublisherRequest_default_instance_; +class CreatePublisherResponse; +struct CreatePublisherResponseDefaultTypeInternal; +extern CreatePublisherResponseDefaultTypeInternal _CreatePublisherResponse_default_instance_; +class CreateSubscriberRequest; +struct CreateSubscriberRequestDefaultTypeInternal; +extern CreateSubscriberRequestDefaultTypeInternal _CreateSubscriberRequest_default_instance_; +class CreateSubscriberResponse; +struct CreateSubscriberResponseDefaultTypeInternal; +extern CreateSubscriberResponseDefaultTypeInternal _CreateSubscriberResponse_default_instance_; +class Discovery; +struct DiscoveryDefaultTypeInternal; +extern DiscoveryDefaultTypeInternal _Discovery_default_instance_; +class Discovery_Advertise; +struct Discovery_AdvertiseDefaultTypeInternal; +extern Discovery_AdvertiseDefaultTypeInternal _Discovery_Advertise_default_instance_; +class Discovery_Query; +struct Discovery_QueryDefaultTypeInternal; +extern Discovery_QueryDefaultTypeInternal _Discovery_Query_default_instance_; +class Discovery_Subscribe; +struct Discovery_SubscribeDefaultTypeInternal; +extern Discovery_SubscribeDefaultTypeInternal _Discovery_Subscribe_default_instance_; +class GetChannelInfoRequest; +struct GetChannelInfoRequestDefaultTypeInternal; +extern GetChannelInfoRequestDefaultTypeInternal _GetChannelInfoRequest_default_instance_; +class GetChannelInfoResponse; +struct GetChannelInfoResponseDefaultTypeInternal; +extern GetChannelInfoResponseDefaultTypeInternal _GetChannelInfoResponse_default_instance_; +class GetChannelStatsRequest; +struct GetChannelStatsRequestDefaultTypeInternal; +extern GetChannelStatsRequestDefaultTypeInternal _GetChannelStatsRequest_default_instance_; +class GetChannelStatsResponse; +struct GetChannelStatsResponseDefaultTypeInternal; +extern GetChannelStatsResponseDefaultTypeInternal _GetChannelStatsResponse_default_instance_; +class GetTriggersRequest; +struct GetTriggersRequestDefaultTypeInternal; +extern GetTriggersRequestDefaultTypeInternal _GetTriggersRequest_default_instance_; +class GetTriggersResponse; +struct GetTriggersResponseDefaultTypeInternal; +extern GetTriggersResponseDefaultTypeInternal _GetTriggersResponse_default_instance_; +class InitRequest; +struct InitRequestDefaultTypeInternal; +extern InitRequestDefaultTypeInternal _InitRequest_default_instance_; +class InitResponse; +struct InitResponseDefaultTypeInternal; +extern InitResponseDefaultTypeInternal _InitResponse_default_instance_; +class RawMessage; +struct RawMessageDefaultTypeInternal; +extern RawMessageDefaultTypeInternal _RawMessage_default_instance_; +class RegisterClientBufferRequest; +struct RegisterClientBufferRequestDefaultTypeInternal; +extern RegisterClientBufferRequestDefaultTypeInternal _RegisterClientBufferRequest_default_instance_; +class RemovePublisherRequest; +struct RemovePublisherRequestDefaultTypeInternal; +extern RemovePublisherRequestDefaultTypeInternal _RemovePublisherRequest_default_instance_; +class RemovePublisherResponse; +struct RemovePublisherResponseDefaultTypeInternal; +extern RemovePublisherResponseDefaultTypeInternal _RemovePublisherResponse_default_instance_; +class RemoveSubscriberRequest; +struct RemoveSubscriberRequestDefaultTypeInternal; +extern RemoveSubscriberRequestDefaultTypeInternal _RemoveSubscriberRequest_default_instance_; +class RemoveSubscriberResponse; +struct RemoveSubscriberResponseDefaultTypeInternal; +extern RemoveSubscriberResponseDefaultTypeInternal _RemoveSubscriberResponse_default_instance_; +class Request; +struct RequestDefaultTypeInternal; +extern RequestDefaultTypeInternal _Request_default_instance_; +class Response; +struct ResponseDefaultTypeInternal; +extern ResponseDefaultTypeInternal _Response_default_instance_; +class RetirementNotification; +struct RetirementNotificationDefaultTypeInternal; +extern RetirementNotificationDefaultTypeInternal _RetirementNotification_default_instance_; +class RpcCancelRequest; +struct RpcCancelRequestDefaultTypeInternal; +extern RpcCancelRequestDefaultTypeInternal _RpcCancelRequest_default_instance_; +class RpcCloseRequest; +struct RpcCloseRequestDefaultTypeInternal; +extern RpcCloseRequestDefaultTypeInternal _RpcCloseRequest_default_instance_; +class RpcCloseResponse; +struct RpcCloseResponseDefaultTypeInternal; +extern RpcCloseResponseDefaultTypeInternal _RpcCloseResponse_default_instance_; +class RpcOpenRequest; +struct RpcOpenRequestDefaultTypeInternal; +extern RpcOpenRequestDefaultTypeInternal _RpcOpenRequest_default_instance_; +class RpcOpenResponse; +struct RpcOpenResponseDefaultTypeInternal; +extern RpcOpenResponseDefaultTypeInternal _RpcOpenResponse_default_instance_; +class RpcOpenResponse_Method; +struct RpcOpenResponse_MethodDefaultTypeInternal; +extern RpcOpenResponse_MethodDefaultTypeInternal _RpcOpenResponse_Method_default_instance_; +class RpcOpenResponse_RequestChannel; +struct RpcOpenResponse_RequestChannelDefaultTypeInternal; +extern RpcOpenResponse_RequestChannelDefaultTypeInternal _RpcOpenResponse_RequestChannel_default_instance_; +class RpcOpenResponse_ResponseChannel; +struct RpcOpenResponse_ResponseChannelDefaultTypeInternal; +extern RpcOpenResponse_ResponseChannelDefaultTypeInternal _RpcOpenResponse_ResponseChannel_default_instance_; +class RpcRequest; +struct RpcRequestDefaultTypeInternal; +extern RpcRequestDefaultTypeInternal _RpcRequest_default_instance_; +class RpcResponse; +struct RpcResponseDefaultTypeInternal; +extern RpcResponseDefaultTypeInternal _RpcResponse_default_instance_; +class RpcServerRequest; +struct RpcServerRequestDefaultTypeInternal; +extern RpcServerRequestDefaultTypeInternal _RpcServerRequest_default_instance_; +class RpcServerResponse; +struct RpcServerResponseDefaultTypeInternal; +extern RpcServerResponseDefaultTypeInternal _RpcServerResponse_default_instance_; +class ShadowAddPublisher; +struct ShadowAddPublisherDefaultTypeInternal; +extern ShadowAddPublisherDefaultTypeInternal _ShadowAddPublisher_default_instance_; +class ShadowAddSubscriber; +struct ShadowAddSubscriberDefaultTypeInternal; +extern ShadowAddSubscriberDefaultTypeInternal _ShadowAddSubscriber_default_instance_; +class ShadowCreateChannel; +struct ShadowCreateChannelDefaultTypeInternal; +extern ShadowCreateChannelDefaultTypeInternal _ShadowCreateChannel_default_instance_; +class ShadowEvent; +struct ShadowEventDefaultTypeInternal; +extern ShadowEventDefaultTypeInternal _ShadowEvent_default_instance_; +class ShadowInit; +struct ShadowInitDefaultTypeInternal; +extern ShadowInitDefaultTypeInternal _ShadowInit_default_instance_; +class ShadowRegisterClientBuffer; +struct ShadowRegisterClientBufferDefaultTypeInternal; +extern ShadowRegisterClientBufferDefaultTypeInternal _ShadowRegisterClientBuffer_default_instance_; +class ShadowRemoveChannel; +struct ShadowRemoveChannelDefaultTypeInternal; +extern ShadowRemoveChannelDefaultTypeInternal _ShadowRemoveChannel_default_instance_; +class ShadowRemovePublisher; +struct ShadowRemovePublisherDefaultTypeInternal; +extern ShadowRemovePublisherDefaultTypeInternal _ShadowRemovePublisher_default_instance_; +class ShadowRemoveSubscriber; +struct ShadowRemoveSubscriberDefaultTypeInternal; +extern ShadowRemoveSubscriberDefaultTypeInternal _ShadowRemoveSubscriber_default_instance_; +class ShadowStateDone; +struct ShadowStateDoneDefaultTypeInternal; +extern ShadowStateDoneDefaultTypeInternal _ShadowStateDone_default_instance_; +class ShadowStateDump; +struct ShadowStateDumpDefaultTypeInternal; +extern ShadowStateDumpDefaultTypeInternal _ShadowStateDump_default_instance_; +class ShadowUnregisterClientBuffer; +struct ShadowUnregisterClientBufferDefaultTypeInternal; +extern ShadowUnregisterClientBufferDefaultTypeInternal _ShadowUnregisterClientBuffer_default_instance_; +class ShadowUpdateChannelOptions; +struct ShadowUpdateChannelOptionsDefaultTypeInternal; +extern ShadowUpdateChannelOptionsDefaultTypeInternal _ShadowUpdateChannelOptions_default_instance_; +class Statistics; +struct StatisticsDefaultTypeInternal; +extern StatisticsDefaultTypeInternal _Statistics_default_instance_; +class Subscribed; +struct SubscribedDefaultTypeInternal; +extern SubscribedDefaultTypeInternal _Subscribed_default_instance_; +class UnregisterClientBufferRequest; +struct UnregisterClientBufferRequestDefaultTypeInternal; +extern UnregisterClientBufferRequestDefaultTypeInternal _UnregisterClientBufferRequest_default_instance_; +class VoidMessage; +struct VoidMessageDefaultTypeInternal; +extern VoidMessageDefaultTypeInternal _VoidMessage_default_instance_; +} // namespace subspace +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace subspace { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class VoidMessage final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:subspace.VoidMessage) */ { + public: + inline VoidMessage() : VoidMessage(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(VoidMessage* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(VoidMessage)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR VoidMessage( + ::google::protobuf::internal::ConstantInitialized); + + inline VoidMessage(const VoidMessage& from) : VoidMessage(nullptr, from) {} + inline VoidMessage(VoidMessage&& from) noexcept + : VoidMessage(nullptr, std::move(from)) {} + inline VoidMessage& operator=(const VoidMessage& from) { + CopyFrom(from); + return *this; + } + inline VoidMessage& operator=(VoidMessage&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const VoidMessage& default_instance() { + return *internal_default_instance(); + } + static inline const VoidMessage* internal_default_instance() { + return reinterpret_cast( + &_VoidMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = 45; + friend void swap(VoidMessage& a, VoidMessage& b) { a.Swap(&b); } + inline void Swap(VoidMessage* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(VoidMessage* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VoidMessage* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const VoidMessage& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const VoidMessage& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.VoidMessage"; } + + protected: + explicit VoidMessage(::google::protobuf::Arena* arena); + VoidMessage(::google::protobuf::Arena* arena, const VoidMessage& from); + VoidMessage(::google::protobuf::Arena* arena, VoidMessage&& from) noexcept + : VoidMessage(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:subspace.VoidMessage) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const VoidMessage& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class UnregisterClientBufferRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.UnregisterClientBufferRequest) */ { + public: + inline UnregisterClientBufferRequest() : UnregisterClientBufferRequest(nullptr) {} + ~UnregisterClientBufferRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UnregisterClientBufferRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UnregisterClientBufferRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UnregisterClientBufferRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline UnregisterClientBufferRequest(const UnregisterClientBufferRequest& from) : UnregisterClientBufferRequest(nullptr, from) {} + inline UnregisterClientBufferRequest(UnregisterClientBufferRequest&& from) noexcept + : UnregisterClientBufferRequest(nullptr, std::move(from)) {} + inline UnregisterClientBufferRequest& operator=(const UnregisterClientBufferRequest& from) { + CopyFrom(from); + return *this; + } + inline UnregisterClientBufferRequest& operator=(UnregisterClientBufferRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const UnregisterClientBufferRequest& default_instance() { + return *internal_default_instance(); + } + static inline const UnregisterClientBufferRequest* internal_default_instance() { + return reinterpret_cast( + &_UnregisterClientBufferRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 18; + friend void swap(UnregisterClientBufferRequest& a, UnregisterClientBufferRequest& b) { a.Swap(&b); } + inline void Swap(UnregisterClientBufferRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UnregisterClientBufferRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UnregisterClientBufferRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const UnregisterClientBufferRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const UnregisterClientBufferRequest& from) { UnregisterClientBufferRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UnregisterClientBufferRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.UnregisterClientBufferRequest"; } + + protected: + explicit UnregisterClientBufferRequest(::google::protobuf::Arena* arena); + UnregisterClientBufferRequest(::google::protobuf::Arena* arena, const UnregisterClientBufferRequest& from); + UnregisterClientBufferRequest(::google::protobuf::Arena* arena, UnregisterClientBufferRequest&& from) noexcept + : UnregisterClientBufferRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kSessionIdFieldNumber = 2, + kBufferIndexFieldNumber = 3, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // uint64 session_id = 2; + void clear_session_id() ; + ::uint64_t session_id() const; + void set_session_id(::uint64_t value); + + private: + ::uint64_t _internal_session_id() const; + void _internal_set_session_id(::uint64_t value); + + public: + // uint32 buffer_index = 3; + void clear_buffer_index() ; + ::uint32_t buffer_index() const; + void set_buffer_index(::uint32_t value); + + private: + ::uint32_t _internal_buffer_index() const; + void _internal_set_buffer_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.UnregisterClientBufferRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 59, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UnregisterClientBufferRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::uint64_t session_id_; + ::uint32_t buffer_index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowUpdateChannelOptions final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowUpdateChannelOptions) */ { + public: + inline ShadowUpdateChannelOptions() : ShadowUpdateChannelOptions(nullptr) {} + ~ShadowUpdateChannelOptions() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowUpdateChannelOptions* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowUpdateChannelOptions)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowUpdateChannelOptions( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowUpdateChannelOptions(const ShadowUpdateChannelOptions& from) : ShadowUpdateChannelOptions(nullptr, from) {} + inline ShadowUpdateChannelOptions(ShadowUpdateChannelOptions&& from) noexcept + : ShadowUpdateChannelOptions(nullptr, std::move(from)) {} + inline ShadowUpdateChannelOptions& operator=(const ShadowUpdateChannelOptions& from) { + CopyFrom(from); + return *this; + } + inline ShadowUpdateChannelOptions& operator=(ShadowUpdateChannelOptions&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowUpdateChannelOptions& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowUpdateChannelOptions* internal_default_instance() { + return reinterpret_cast( + &_ShadowUpdateChannelOptions_default_instance_); + } + static constexpr int kIndexInFileMessages = 58; + friend void swap(ShadowUpdateChannelOptions& a, ShadowUpdateChannelOptions& b) { a.Swap(&b); } + inline void Swap(ShadowUpdateChannelOptions* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowUpdateChannelOptions* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowUpdateChannelOptions* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowUpdateChannelOptions& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowUpdateChannelOptions& from) { ShadowUpdateChannelOptions::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowUpdateChannelOptions* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowUpdateChannelOptions"; } + + protected: + explicit ShadowUpdateChannelOptions(::google::protobuf::Arena* arena); + ShadowUpdateChannelOptions(::google::protobuf::Arena* arena, const ShadowUpdateChannelOptions& from); + ShadowUpdateChannelOptions(::google::protobuf::Arena* arena, ShadowUpdateChannelOptions&& from) noexcept + : ShadowUpdateChannelOptions(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kHasSplitBufferOptionsFieldNumber = 2, + kUseSplitBuffersFieldNumber = 3, + kHasMaxPublishersFieldNumber = 4, + kSplitBuffersOverBridgeFieldNumber = 6, + kMaxPublishersFieldNumber = 5, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // bool has_split_buffer_options = 2; + void clear_has_split_buffer_options() ; + bool has_split_buffer_options() const; + void set_has_split_buffer_options(bool value); + + private: + bool _internal_has_split_buffer_options() const; + void _internal_set_has_split_buffer_options(bool value); + + public: + // bool use_split_buffers = 3; + void clear_use_split_buffers() ; + bool use_split_buffers() const; + void set_use_split_buffers(bool value); + + private: + bool _internal_use_split_buffers() const; + void _internal_set_use_split_buffers(bool value); + + public: + // bool has_max_publishers = 4; + void clear_has_max_publishers() ; + bool has_max_publishers() const; + void set_has_max_publishers(bool value); + + private: + bool _internal_has_max_publishers() const; + void _internal_set_has_max_publishers(bool value); + + public: + // bool split_buffers_over_bridge = 6; + void clear_split_buffers_over_bridge() ; + bool split_buffers_over_bridge() const; + void set_split_buffers_over_bridge(bool value); + + private: + bool _internal_split_buffers_over_bridge() const; + void _internal_set_split_buffers_over_bridge(bool value); + + public: + // int32 max_publishers = 5; + void clear_max_publishers() ; + ::int32_t max_publishers() const; + void set_max_publishers(::int32_t value); + + private: + ::int32_t _internal_max_publishers() const; + void _internal_set_max_publishers(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowUpdateChannelOptions) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 6, 0, + 56, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowUpdateChannelOptions& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + bool has_split_buffer_options_; + bool use_split_buffers_; + bool has_max_publishers_; + bool split_buffers_over_bridge_; + ::int32_t max_publishers_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowUnregisterClientBuffer final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowUnregisterClientBuffer) */ { + public: + inline ShadowUnregisterClientBuffer() : ShadowUnregisterClientBuffer(nullptr) {} + ~ShadowUnregisterClientBuffer() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowUnregisterClientBuffer* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowUnregisterClientBuffer)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowUnregisterClientBuffer( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowUnregisterClientBuffer(const ShadowUnregisterClientBuffer& from) : ShadowUnregisterClientBuffer(nullptr, from) {} + inline ShadowUnregisterClientBuffer(ShadowUnregisterClientBuffer&& from) noexcept + : ShadowUnregisterClientBuffer(nullptr, std::move(from)) {} + inline ShadowUnregisterClientBuffer& operator=(const ShadowUnregisterClientBuffer& from) { + CopyFrom(from); + return *this; + } + inline ShadowUnregisterClientBuffer& operator=(ShadowUnregisterClientBuffer&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowUnregisterClientBuffer& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowUnregisterClientBuffer* internal_default_instance() { + return reinterpret_cast( + &_ShadowUnregisterClientBuffer_default_instance_); + } + static constexpr int kIndexInFileMessages = 57; + friend void swap(ShadowUnregisterClientBuffer& a, ShadowUnregisterClientBuffer& b) { a.Swap(&b); } + inline void Swap(ShadowUnregisterClientBuffer* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowUnregisterClientBuffer* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowUnregisterClientBuffer* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowUnregisterClientBuffer& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowUnregisterClientBuffer& from) { ShadowUnregisterClientBuffer::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowUnregisterClientBuffer* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowUnregisterClientBuffer"; } + + protected: + explicit ShadowUnregisterClientBuffer(::google::protobuf::Arena* arena); + ShadowUnregisterClientBuffer(::google::protobuf::Arena* arena, const ShadowUnregisterClientBuffer& from); + ShadowUnregisterClientBuffer(::google::protobuf::Arena* arena, ShadowUnregisterClientBuffer&& from) noexcept + : ShadowUnregisterClientBuffer(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kSessionIdFieldNumber = 2, + kBufferIndexFieldNumber = 3, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // uint64 session_id = 2; + void clear_session_id() ; + ::uint64_t session_id() const; + void set_session_id(::uint64_t value); + + private: + ::uint64_t _internal_session_id() const; + void _internal_set_session_id(::uint64_t value); + + public: + // uint32 buffer_index = 3; + void clear_buffer_index() ; + ::uint32_t buffer_index() const; + void set_buffer_index(::uint32_t value); + + private: + ::uint32_t _internal_buffer_index() const; + void _internal_set_buffer_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowUnregisterClientBuffer) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 58, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowUnregisterClientBuffer& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::uint64_t session_id_; + ::uint32_t buffer_index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowStateDump final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowStateDump) */ { + public: + inline ShadowStateDump() : ShadowStateDump(nullptr) {} + ~ShadowStateDump() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowStateDump* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowStateDump)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowStateDump( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowStateDump(const ShadowStateDump& from) : ShadowStateDump(nullptr, from) {} + inline ShadowStateDump(ShadowStateDump&& from) noexcept + : ShadowStateDump(nullptr, std::move(from)) {} + inline ShadowStateDump& operator=(const ShadowStateDump& from) { + CopyFrom(from); + return *this; + } + inline ShadowStateDump& operator=(ShadowStateDump&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowStateDump& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowStateDump* internal_default_instance() { + return reinterpret_cast( + &_ShadowStateDump_default_instance_); + } + static constexpr int kIndexInFileMessages = 54; + friend void swap(ShadowStateDump& a, ShadowStateDump& b) { a.Swap(&b); } + inline void Swap(ShadowStateDump* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowStateDump* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowStateDump* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowStateDump& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowStateDump& from) { ShadowStateDump::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowStateDump* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowStateDump"; } + + protected: + explicit ShadowStateDump(::google::protobuf::Arena* arena); + ShadowStateDump(::google::protobuf::Arena* arena, const ShadowStateDump& from); + ShadowStateDump(::google::protobuf::Arena* arena, ShadowStateDump&& from) noexcept + : ShadowStateDump(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSessionIdFieldNumber = 1, + kNumChannelsFieldNumber = 2, + }; + // uint64 session_id = 1; + void clear_session_id() ; + ::uint64_t session_id() const; + void set_session_id(::uint64_t value); + + private: + ::uint64_t _internal_session_id() const; + void _internal_set_session_id(::uint64_t value); + + public: + // int32 num_channels = 2; + void clear_num_channels() ; + ::int32_t num_channels() const; + void set_num_channels(::int32_t value); + + private: + ::int32_t _internal_num_channels() const; + void _internal_set_num_channels(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowStateDump) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowStateDump& from_msg); + ::uint64_t session_id_; + ::int32_t num_channels_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowStateDone final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:subspace.ShadowStateDone) */ { + public: + inline ShadowStateDone() : ShadowStateDone(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowStateDone* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowStateDone)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowStateDone( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowStateDone(const ShadowStateDone& from) : ShadowStateDone(nullptr, from) {} + inline ShadowStateDone(ShadowStateDone&& from) noexcept + : ShadowStateDone(nullptr, std::move(from)) {} + inline ShadowStateDone& operator=(const ShadowStateDone& from) { + CopyFrom(from); + return *this; + } + inline ShadowStateDone& operator=(ShadowStateDone&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowStateDone& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowStateDone* internal_default_instance() { + return reinterpret_cast( + &_ShadowStateDone_default_instance_); + } + static constexpr int kIndexInFileMessages = 55; + friend void swap(ShadowStateDone& a, ShadowStateDone& b) { a.Swap(&b); } + inline void Swap(ShadowStateDone* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowStateDone* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowStateDone* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const ShadowStateDone& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const ShadowStateDone& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowStateDone"; } + + protected: + explicit ShadowStateDone(::google::protobuf::Arena* arena); + ShadowStateDone(::google::protobuf::Arena* arena, const ShadowStateDone& from); + ShadowStateDone(::google::protobuf::Arena* arena, ShadowStateDone&& from) noexcept + : ShadowStateDone(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:subspace.ShadowStateDone) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowStateDone& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowRemoveSubscriber final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowRemoveSubscriber) */ { + public: + inline ShadowRemoveSubscriber() : ShadowRemoveSubscriber(nullptr) {} + ~ShadowRemoveSubscriber() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowRemoveSubscriber* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowRemoveSubscriber)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowRemoveSubscriber( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowRemoveSubscriber(const ShadowRemoveSubscriber& from) : ShadowRemoveSubscriber(nullptr, from) {} + inline ShadowRemoveSubscriber(ShadowRemoveSubscriber&& from) noexcept + : ShadowRemoveSubscriber(nullptr, std::move(from)) {} + inline ShadowRemoveSubscriber& operator=(const ShadowRemoveSubscriber& from) { + CopyFrom(from); + return *this; + } + inline ShadowRemoveSubscriber& operator=(ShadowRemoveSubscriber&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowRemoveSubscriber& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowRemoveSubscriber* internal_default_instance() { + return reinterpret_cast( + &_ShadowRemoveSubscriber_default_instance_); + } + static constexpr int kIndexInFileMessages = 53; + friend void swap(ShadowRemoveSubscriber& a, ShadowRemoveSubscriber& b) { a.Swap(&b); } + inline void Swap(ShadowRemoveSubscriber* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowRemoveSubscriber* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowRemoveSubscriber* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowRemoveSubscriber& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowRemoveSubscriber& from) { ShadowRemoveSubscriber::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowRemoveSubscriber* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowRemoveSubscriber"; } + + protected: + explicit ShadowRemoveSubscriber(::google::protobuf::Arena* arena); + ShadowRemoveSubscriber(::google::protobuf::Arena* arena, const ShadowRemoveSubscriber& from); + ShadowRemoveSubscriber(::google::protobuf::Arena* arena, ShadowRemoveSubscriber&& from) noexcept + : ShadowRemoveSubscriber(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kSubscriberIdFieldNumber = 2, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 subscriber_id = 2; + void clear_subscriber_id() ; + ::int32_t subscriber_id() const; + void set_subscriber_id(::int32_t value); + + private: + ::int32_t _internal_subscriber_id() const; + void _internal_set_subscriber_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowRemoveSubscriber) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 52, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowRemoveSubscriber& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t subscriber_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowRemovePublisher final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowRemovePublisher) */ { + public: + inline ShadowRemovePublisher() : ShadowRemovePublisher(nullptr) {} + ~ShadowRemovePublisher() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowRemovePublisher* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowRemovePublisher)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowRemovePublisher( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowRemovePublisher(const ShadowRemovePublisher& from) : ShadowRemovePublisher(nullptr, from) {} + inline ShadowRemovePublisher(ShadowRemovePublisher&& from) noexcept + : ShadowRemovePublisher(nullptr, std::move(from)) {} + inline ShadowRemovePublisher& operator=(const ShadowRemovePublisher& from) { + CopyFrom(from); + return *this; + } + inline ShadowRemovePublisher& operator=(ShadowRemovePublisher&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowRemovePublisher& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowRemovePublisher* internal_default_instance() { + return reinterpret_cast( + &_ShadowRemovePublisher_default_instance_); + } + static constexpr int kIndexInFileMessages = 51; + friend void swap(ShadowRemovePublisher& a, ShadowRemovePublisher& b) { a.Swap(&b); } + inline void Swap(ShadowRemovePublisher* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowRemovePublisher* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowRemovePublisher* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowRemovePublisher& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowRemovePublisher& from) { ShadowRemovePublisher::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowRemovePublisher* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowRemovePublisher"; } + + protected: + explicit ShadowRemovePublisher(::google::protobuf::Arena* arena); + ShadowRemovePublisher(::google::protobuf::Arena* arena, const ShadowRemovePublisher& from); + ShadowRemovePublisher(::google::protobuf::Arena* arena, ShadowRemovePublisher&& from) noexcept + : ShadowRemovePublisher(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kPublisherIdFieldNumber = 2, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 publisher_id = 2; + void clear_publisher_id() ; + ::int32_t publisher_id() const; + void set_publisher_id(::int32_t value); + + private: + ::int32_t _internal_publisher_id() const; + void _internal_set_publisher_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowRemovePublisher) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 51, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowRemovePublisher& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t publisher_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowRemoveChannel final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowRemoveChannel) */ { + public: + inline ShadowRemoveChannel() : ShadowRemoveChannel(nullptr) {} + ~ShadowRemoveChannel() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowRemoveChannel* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowRemoveChannel)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowRemoveChannel( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowRemoveChannel(const ShadowRemoveChannel& from) : ShadowRemoveChannel(nullptr, from) {} + inline ShadowRemoveChannel(ShadowRemoveChannel&& from) noexcept + : ShadowRemoveChannel(nullptr, std::move(from)) {} + inline ShadowRemoveChannel& operator=(const ShadowRemoveChannel& from) { + CopyFrom(from); + return *this; + } + inline ShadowRemoveChannel& operator=(ShadowRemoveChannel&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowRemoveChannel& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowRemoveChannel* internal_default_instance() { + return reinterpret_cast( + &_ShadowRemoveChannel_default_instance_); + } + static constexpr int kIndexInFileMessages = 49; + friend void swap(ShadowRemoveChannel& a, ShadowRemoveChannel& b) { a.Swap(&b); } + inline void Swap(ShadowRemoveChannel* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowRemoveChannel* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowRemoveChannel* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowRemoveChannel& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowRemoveChannel& from) { ShadowRemoveChannel::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowRemoveChannel* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowRemoveChannel"; } + + protected: + explicit ShadowRemoveChannel(::google::protobuf::Arena* arena); + ShadowRemoveChannel(::google::protobuf::Arena* arena, const ShadowRemoveChannel& from); + ShadowRemoveChannel(::google::protobuf::Arena* arena, ShadowRemoveChannel&& from) noexcept + : ShadowRemoveChannel(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kChannelIdFieldNumber = 2, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 channel_id = 2; + void clear_channel_id() ; + ::int32_t channel_id() const; + void set_channel_id(::int32_t value); + + private: + ::int32_t _internal_channel_id() const; + void _internal_set_channel_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowRemoveChannel) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 49, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowRemoveChannel& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t channel_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowInit final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowInit) */ { + public: + inline ShadowInit() : ShadowInit(nullptr) {} + ~ShadowInit() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowInit* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowInit)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowInit( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowInit(const ShadowInit& from) : ShadowInit(nullptr, from) {} + inline ShadowInit(ShadowInit&& from) noexcept + : ShadowInit(nullptr, std::move(from)) {} + inline ShadowInit& operator=(const ShadowInit& from) { + CopyFrom(from); + return *this; + } + inline ShadowInit& operator=(ShadowInit&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowInit& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowInit* internal_default_instance() { + return reinterpret_cast( + &_ShadowInit_default_instance_); + } + static constexpr int kIndexInFileMessages = 47; + friend void swap(ShadowInit& a, ShadowInit& b) { a.Swap(&b); } + inline void Swap(ShadowInit* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowInit* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowInit* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowInit& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowInit& from) { ShadowInit::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowInit* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowInit"; } + + protected: + explicit ShadowInit(::google::protobuf::Arena* arena); + ShadowInit(::google::protobuf::Arena* arena, const ShadowInit& from); + ShadowInit(::google::protobuf::Arena* arena, ShadowInit&& from) noexcept + : ShadowInit(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSessionIdFieldNumber = 1, + }; + // uint64 session_id = 1; + void clear_session_id() ; + ::uint64_t session_id() const; + void set_session_id(::uint64_t value); + + private: + ::uint64_t _internal_session_id() const; + void _internal_set_session_id(::uint64_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowInit) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowInit& from_msg); + ::uint64_t session_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowCreateChannel final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowCreateChannel) */ { + public: + inline ShadowCreateChannel() : ShadowCreateChannel(nullptr) {} + ~ShadowCreateChannel() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowCreateChannel* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowCreateChannel)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowCreateChannel( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowCreateChannel(const ShadowCreateChannel& from) : ShadowCreateChannel(nullptr, from) {} + inline ShadowCreateChannel(ShadowCreateChannel&& from) noexcept + : ShadowCreateChannel(nullptr, std::move(from)) {} + inline ShadowCreateChannel& operator=(const ShadowCreateChannel& from) { + CopyFrom(from); + return *this; + } + inline ShadowCreateChannel& operator=(ShadowCreateChannel&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowCreateChannel& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowCreateChannel* internal_default_instance() { + return reinterpret_cast( + &_ShadowCreateChannel_default_instance_); + } + static constexpr int kIndexInFileMessages = 48; + friend void swap(ShadowCreateChannel& a, ShadowCreateChannel& b) { a.Swap(&b); } + inline void Swap(ShadowCreateChannel* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowCreateChannel* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowCreateChannel* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowCreateChannel& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowCreateChannel& from) { ShadowCreateChannel::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowCreateChannel* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowCreateChannel"; } + + protected: + explicit ShadowCreateChannel(::google::protobuf::Arena* arena); + ShadowCreateChannel(::google::protobuf::Arena* arena, const ShadowCreateChannel& from); + ShadowCreateChannel(::google::protobuf::Arena* arena, ShadowCreateChannel&& from) noexcept + : ShadowCreateChannel(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kTypeFieldNumber = 5, + kMuxFieldNumber = 11, + kChannelIdFieldNumber = 2, + kSlotSizeFieldNumber = 3, + kNumSlotsFieldNumber = 4, + kIsLocalFieldNumber = 6, + kIsReliableFieldNumber = 7, + kIsFixedSizeFieldNumber = 8, + kHasSplitBufferOptionsFieldNumber = 13, + kChecksumSizeFieldNumber = 9, + kMetadataSizeFieldNumber = 10, + kVchanIdFieldNumber = 12, + kUseSplitBuffersFieldNumber = 14, + kHasMaxPublishersFieldNumber = 15, + kSplitBuffersOverBridgeFieldNumber = 17, + kMaxPublishersFieldNumber = 16, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // bytes type = 5; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // string mux = 11; + void clear_mux() ; + const std::string& mux() const; + template + void set_mux(Arg_&& arg, Args_... args); + std::string* mutable_mux(); + PROTOBUF_NODISCARD std::string* release_mux(); + void set_allocated_mux(std::string* value); + + private: + const std::string& _internal_mux() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mux( + const std::string& value); + std::string* _internal_mutable_mux(); + + public: + // int32 channel_id = 2; + void clear_channel_id() ; + ::int32_t channel_id() const; + void set_channel_id(::int32_t value); + + private: + ::int32_t _internal_channel_id() const; + void _internal_set_channel_id(::int32_t value); + + public: + // int32 slot_size = 3; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // int32 num_slots = 4; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // bool is_local = 6; + void clear_is_local() ; + bool is_local() const; + void set_is_local(bool value); + + private: + bool _internal_is_local() const; + void _internal_set_is_local(bool value); + + public: + // bool is_reliable = 7; + void clear_is_reliable() ; + bool is_reliable() const; + void set_is_reliable(bool value); + + private: + bool _internal_is_reliable() const; + void _internal_set_is_reliable(bool value); + + public: + // bool is_fixed_size = 8; + void clear_is_fixed_size() ; + bool is_fixed_size() const; + void set_is_fixed_size(bool value); + + private: + bool _internal_is_fixed_size() const; + void _internal_set_is_fixed_size(bool value); + + public: + // bool has_split_buffer_options = 13; + void clear_has_split_buffer_options() ; + bool has_split_buffer_options() const; + void set_has_split_buffer_options(bool value); + + private: + bool _internal_has_split_buffer_options() const; + void _internal_set_has_split_buffer_options(bool value); + + public: + // int32 checksum_size = 9; + void clear_checksum_size() ; + ::int32_t checksum_size() const; + void set_checksum_size(::int32_t value); + + private: + ::int32_t _internal_checksum_size() const; + void _internal_set_checksum_size(::int32_t value); + + public: + // int32 metadata_size = 10; + void clear_metadata_size() ; + ::int32_t metadata_size() const; + void set_metadata_size(::int32_t value); + + private: + ::int32_t _internal_metadata_size() const; + void _internal_set_metadata_size(::int32_t value); + + public: + // int32 vchan_id = 12; + void clear_vchan_id() ; + ::int32_t vchan_id() const; + void set_vchan_id(::int32_t value); + + private: + ::int32_t _internal_vchan_id() const; + void _internal_set_vchan_id(::int32_t value); + + public: + // bool use_split_buffers = 14; + void clear_use_split_buffers() ; + bool use_split_buffers() const; + void set_use_split_buffers(bool value); + + private: + bool _internal_use_split_buffers() const; + void _internal_set_use_split_buffers(bool value); + + public: + // bool has_max_publishers = 15; + void clear_has_max_publishers() ; + bool has_max_publishers() const; + void set_has_max_publishers(bool value); + + private: + bool _internal_has_max_publishers() const; + void _internal_set_has_max_publishers(bool value); + + public: + // bool split_buffers_over_bridge = 17; + void clear_split_buffers_over_bridge() ; + bool split_buffers_over_bridge() const; + void set_split_buffers_over_bridge(bool value); + + private: + bool _internal_split_buffers_over_bridge() const; + void _internal_set_split_buffers_over_bridge(bool value); + + public: + // int32 max_publishers = 16; + void clear_max_publishers() ; + ::int32_t max_publishers() const; + void set_max_publishers(::int32_t value); + + private: + ::int32_t _internal_max_publishers() const; + void _internal_set_max_publishers(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowCreateChannel) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 5, 17, 0, + 68, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowCreateChannel& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::ArenaStringPtr mux_; + ::int32_t channel_id_; + ::int32_t slot_size_; + ::int32_t num_slots_; + bool is_local_; + bool is_reliable_; + bool is_fixed_size_; + bool has_split_buffer_options_; + ::int32_t checksum_size_; + ::int32_t metadata_size_; + ::int32_t vchan_id_; + bool use_split_buffers_; + bool has_max_publishers_; + bool split_buffers_over_bridge_; + ::int32_t max_publishers_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowAddSubscriber final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowAddSubscriber) */ { + public: + inline ShadowAddSubscriber() : ShadowAddSubscriber(nullptr) {} + ~ShadowAddSubscriber() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowAddSubscriber* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowAddSubscriber)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowAddSubscriber( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowAddSubscriber(const ShadowAddSubscriber& from) : ShadowAddSubscriber(nullptr, from) {} + inline ShadowAddSubscriber(ShadowAddSubscriber&& from) noexcept + : ShadowAddSubscriber(nullptr, std::move(from)) {} + inline ShadowAddSubscriber& operator=(const ShadowAddSubscriber& from) { + CopyFrom(from); + return *this; + } + inline ShadowAddSubscriber& operator=(ShadowAddSubscriber&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowAddSubscriber& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowAddSubscriber* internal_default_instance() { + return reinterpret_cast( + &_ShadowAddSubscriber_default_instance_); + } + static constexpr int kIndexInFileMessages = 52; + friend void swap(ShadowAddSubscriber& a, ShadowAddSubscriber& b) { a.Swap(&b); } + inline void Swap(ShadowAddSubscriber* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowAddSubscriber* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowAddSubscriber* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowAddSubscriber& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowAddSubscriber& from) { ShadowAddSubscriber::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowAddSubscriber* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowAddSubscriber"; } + + protected: + explicit ShadowAddSubscriber(::google::protobuf::Arena* arena); + ShadowAddSubscriber(::google::protobuf::Arena* arena, const ShadowAddSubscriber& from); + ShadowAddSubscriber(::google::protobuf::Arena* arena, ShadowAddSubscriber&& from) noexcept + : ShadowAddSubscriber(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kSubscriberIdFieldNumber = 2, + kIsReliableFieldNumber = 3, + kIsBridgeFieldNumber = 4, + kForTunnelFieldNumber = 6, + kMaxActiveMessagesFieldNumber = 5, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 subscriber_id = 2; + void clear_subscriber_id() ; + ::int32_t subscriber_id() const; + void set_subscriber_id(::int32_t value); + + private: + ::int32_t _internal_subscriber_id() const; + void _internal_set_subscriber_id(::int32_t value); + + public: + // bool is_reliable = 3; + void clear_is_reliable() ; + bool is_reliable() const; + void set_is_reliable(bool value); + + private: + bool _internal_is_reliable() const; + void _internal_set_is_reliable(bool value); + + public: + // bool is_bridge = 4; + void clear_is_bridge() ; + bool is_bridge() const; + void set_is_bridge(bool value); + + private: + bool _internal_is_bridge() const; + void _internal_set_is_bridge(bool value); + + public: + // bool for_tunnel = 6; + void clear_for_tunnel() ; + bool for_tunnel() const; + void set_for_tunnel(bool value); + + private: + bool _internal_for_tunnel() const; + void _internal_set_for_tunnel(bool value); + + public: + // int32 max_active_messages = 5; + void clear_max_active_messages() ; + ::int32_t max_active_messages() const; + void set_max_active_messages(::int32_t value); + + private: + ::int32_t _internal_max_active_messages() const; + void _internal_set_max_active_messages(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowAddSubscriber) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 6, 0, + 49, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowAddSubscriber& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t subscriber_id_; + bool is_reliable_; + bool is_bridge_; + bool for_tunnel_; + ::int32_t max_active_messages_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowAddPublisher final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowAddPublisher) */ { + public: + inline ShadowAddPublisher() : ShadowAddPublisher(nullptr) {} + ~ShadowAddPublisher() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowAddPublisher* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowAddPublisher)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowAddPublisher( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowAddPublisher(const ShadowAddPublisher& from) : ShadowAddPublisher(nullptr, from) {} + inline ShadowAddPublisher(ShadowAddPublisher&& from) noexcept + : ShadowAddPublisher(nullptr, std::move(from)) {} + inline ShadowAddPublisher& operator=(const ShadowAddPublisher& from) { + CopyFrom(from); + return *this; + } + inline ShadowAddPublisher& operator=(ShadowAddPublisher&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowAddPublisher& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowAddPublisher* internal_default_instance() { + return reinterpret_cast( + &_ShadowAddPublisher_default_instance_); + } + static constexpr int kIndexInFileMessages = 50; + friend void swap(ShadowAddPublisher& a, ShadowAddPublisher& b) { a.Swap(&b); } + inline void Swap(ShadowAddPublisher* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowAddPublisher* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowAddPublisher* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowAddPublisher& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowAddPublisher& from) { ShadowAddPublisher::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowAddPublisher* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowAddPublisher"; } + + protected: + explicit ShadowAddPublisher(::google::protobuf::Arena* arena); + ShadowAddPublisher(::google::protobuf::Arena* arena, const ShadowAddPublisher& from); + ShadowAddPublisher(::google::protobuf::Arena* arena, ShadowAddPublisher&& from) noexcept + : ShadowAddPublisher(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kPublisherIdFieldNumber = 2, + kIsReliableFieldNumber = 3, + kIsLocalFieldNumber = 4, + kIsBridgeFieldNumber = 5, + kIsFixedSizeFieldNumber = 6, + kNotifyRetirementFieldNumber = 7, + kForTunnelFieldNumber = 8, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 publisher_id = 2; + void clear_publisher_id() ; + ::int32_t publisher_id() const; + void set_publisher_id(::int32_t value); + + private: + ::int32_t _internal_publisher_id() const; + void _internal_set_publisher_id(::int32_t value); + + public: + // bool is_reliable = 3; + void clear_is_reliable() ; + bool is_reliable() const; + void set_is_reliable(bool value); + + private: + bool _internal_is_reliable() const; + void _internal_set_is_reliable(bool value); + + public: + // bool is_local = 4; + void clear_is_local() ; + bool is_local() const; + void set_is_local(bool value); + + private: + bool _internal_is_local() const; + void _internal_set_is_local(bool value); + + public: + // bool is_bridge = 5; + void clear_is_bridge() ; + bool is_bridge() const; + void set_is_bridge(bool value); + + private: + bool _internal_is_bridge() const; + void _internal_set_is_bridge(bool value); + + public: + // bool is_fixed_size = 6; + void clear_is_fixed_size() ; + bool is_fixed_size() const; + void set_is_fixed_size(bool value); + + private: + bool _internal_is_fixed_size() const; + void _internal_set_is_fixed_size(bool value); + + public: + // bool notify_retirement = 7; + void clear_notify_retirement() ; + bool notify_retirement() const; + void set_notify_retirement(bool value); + + private: + bool _internal_notify_retirement() const; + void _internal_set_notify_retirement(bool value); + + public: + // bool for_tunnel = 8; + void clear_for_tunnel() ; + bool for_tunnel() const; + void set_for_tunnel(bool value); + + private: + bool _internal_for_tunnel() const; + void _internal_set_for_tunnel(bool value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowAddPublisher) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 8, 0, + 56, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowAddPublisher& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t publisher_id_; + bool is_reliable_; + bool is_local_; + bool is_bridge_; + bool is_fixed_size_; + bool notify_retirement_; + bool for_tunnel_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcOpenResponse_ResponseChannel final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcOpenResponse.ResponseChannel) */ { + public: + inline RpcOpenResponse_ResponseChannel() : RpcOpenResponse_ResponseChannel(nullptr) {} + ~RpcOpenResponse_ResponseChannel() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcOpenResponse_ResponseChannel* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcOpenResponse_ResponseChannel)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcOpenResponse_ResponseChannel( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcOpenResponse_ResponseChannel(const RpcOpenResponse_ResponseChannel& from) : RpcOpenResponse_ResponseChannel(nullptr, from) {} + inline RpcOpenResponse_ResponseChannel(RpcOpenResponse_ResponseChannel&& from) noexcept + : RpcOpenResponse_ResponseChannel(nullptr, std::move(from)) {} + inline RpcOpenResponse_ResponseChannel& operator=(const RpcOpenResponse_ResponseChannel& from) { + CopyFrom(from); + return *this; + } + inline RpcOpenResponse_ResponseChannel& operator=(RpcOpenResponse_ResponseChannel&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcOpenResponse_ResponseChannel& default_instance() { + return *internal_default_instance(); + } + static inline const RpcOpenResponse_ResponseChannel* internal_default_instance() { + return reinterpret_cast( + &_RpcOpenResponse_ResponseChannel_default_instance_); + } + static constexpr int kIndexInFileMessages = 34; + friend void swap(RpcOpenResponse_ResponseChannel& a, RpcOpenResponse_ResponseChannel& b) { a.Swap(&b); } + inline void Swap(RpcOpenResponse_ResponseChannel* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcOpenResponse_ResponseChannel* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcOpenResponse_ResponseChannel* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcOpenResponse_ResponseChannel& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcOpenResponse_ResponseChannel& from) { RpcOpenResponse_ResponseChannel::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcOpenResponse_ResponseChannel* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcOpenResponse.ResponseChannel"; } + + protected: + explicit RpcOpenResponse_ResponseChannel(::google::protobuf::Arena* arena); + RpcOpenResponse_ResponseChannel(::google::protobuf::Arena* arena, const RpcOpenResponse_ResponseChannel& from); + RpcOpenResponse_ResponseChannel(::google::protobuf::Arena* arena, RpcOpenResponse_ResponseChannel&& from) noexcept + : RpcOpenResponse_ResponseChannel(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kNameFieldNumber = 1, + kTypeFieldNumber = 2, + }; + // string name = 1; + void clear_name() ; + const std::string& name() const; + template + void set_name(Arg_&& arg, Args_... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* value); + + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( + const std::string& value); + std::string* _internal_mutable_name(); + + public: + // string type = 2; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcOpenResponse.ResponseChannel) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 57, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcOpenResponse_ResponseChannel& from_msg); + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcOpenResponse_RequestChannel final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcOpenResponse.RequestChannel) */ { + public: + inline RpcOpenResponse_RequestChannel() : RpcOpenResponse_RequestChannel(nullptr) {} + ~RpcOpenResponse_RequestChannel() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcOpenResponse_RequestChannel* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcOpenResponse_RequestChannel)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcOpenResponse_RequestChannel( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcOpenResponse_RequestChannel(const RpcOpenResponse_RequestChannel& from) : RpcOpenResponse_RequestChannel(nullptr, from) {} + inline RpcOpenResponse_RequestChannel(RpcOpenResponse_RequestChannel&& from) noexcept + : RpcOpenResponse_RequestChannel(nullptr, std::move(from)) {} + inline RpcOpenResponse_RequestChannel& operator=(const RpcOpenResponse_RequestChannel& from) { + CopyFrom(from); + return *this; + } + inline RpcOpenResponse_RequestChannel& operator=(RpcOpenResponse_RequestChannel&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcOpenResponse_RequestChannel& default_instance() { + return *internal_default_instance(); + } + static inline const RpcOpenResponse_RequestChannel* internal_default_instance() { + return reinterpret_cast( + &_RpcOpenResponse_RequestChannel_default_instance_); + } + static constexpr int kIndexInFileMessages = 33; + friend void swap(RpcOpenResponse_RequestChannel& a, RpcOpenResponse_RequestChannel& b) { a.Swap(&b); } + inline void Swap(RpcOpenResponse_RequestChannel* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcOpenResponse_RequestChannel* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcOpenResponse_RequestChannel* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcOpenResponse_RequestChannel& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcOpenResponse_RequestChannel& from) { RpcOpenResponse_RequestChannel::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcOpenResponse_RequestChannel* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcOpenResponse.RequestChannel"; } + + protected: + explicit RpcOpenResponse_RequestChannel(::google::protobuf::Arena* arena); + RpcOpenResponse_RequestChannel(::google::protobuf::Arena* arena, const RpcOpenResponse_RequestChannel& from); + RpcOpenResponse_RequestChannel(::google::protobuf::Arena* arena, RpcOpenResponse_RequestChannel&& from) noexcept + : RpcOpenResponse_RequestChannel(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kNameFieldNumber = 1, + kTypeFieldNumber = 4, + kSlotSizeFieldNumber = 2, + kNumSlotsFieldNumber = 3, + }; + // string name = 1; + void clear_name() ; + const std::string& name() const; + template + void set_name(Arg_&& arg, Args_... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* value); + + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( + const std::string& value); + std::string* _internal_mutable_name(); + + public: + // string type = 4; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // int32 slot_size = 2; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // int32 num_slots = 3; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcOpenResponse.RequestChannel) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 4, 0, + 56, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcOpenResponse_RequestChannel& from_msg); + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::int32_t slot_size_; + ::int32_t num_slots_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcOpenRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:subspace.RpcOpenRequest) */ { + public: + inline RpcOpenRequest() : RpcOpenRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcOpenRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcOpenRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcOpenRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcOpenRequest(const RpcOpenRequest& from) : RpcOpenRequest(nullptr, from) {} + inline RpcOpenRequest(RpcOpenRequest&& from) noexcept + : RpcOpenRequest(nullptr, std::move(from)) {} + inline RpcOpenRequest& operator=(const RpcOpenRequest& from) { + CopyFrom(from); + return *this; + } + inline RpcOpenRequest& operator=(RpcOpenRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcOpenRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RpcOpenRequest* internal_default_instance() { + return reinterpret_cast( + &_RpcOpenRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 32; + friend void swap(RpcOpenRequest& a, RpcOpenRequest& b) { a.Swap(&b); } + inline void Swap(RpcOpenRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcOpenRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcOpenRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const RpcOpenRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const RpcOpenRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcOpenRequest"; } + + protected: + explicit RpcOpenRequest(::google::protobuf::Arena* arena); + RpcOpenRequest(::google::protobuf::Arena* arena, const RpcOpenRequest& from); + RpcOpenRequest(::google::protobuf::Arena* arena, RpcOpenRequest&& from) noexcept + : RpcOpenRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:subspace.RpcOpenRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcOpenRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcCloseResponse final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:subspace.RpcCloseResponse) */ { + public: + inline RpcCloseResponse() : RpcCloseResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcCloseResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcCloseResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcCloseResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcCloseResponse(const RpcCloseResponse& from) : RpcCloseResponse(nullptr, from) {} + inline RpcCloseResponse(RpcCloseResponse&& from) noexcept + : RpcCloseResponse(nullptr, std::move(from)) {} + inline RpcCloseResponse& operator=(const RpcCloseResponse& from) { + CopyFrom(from); + return *this; + } + inline RpcCloseResponse& operator=(RpcCloseResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcCloseResponse& default_instance() { + return *internal_default_instance(); + } + static inline const RpcCloseResponse* internal_default_instance() { + return reinterpret_cast( + &_RpcCloseResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 38; + friend void swap(RpcCloseResponse& a, RpcCloseResponse& b) { a.Swap(&b); } + inline void Swap(RpcCloseResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcCloseResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcCloseResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const RpcCloseResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const RpcCloseResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcCloseResponse"; } + + protected: + explicit RpcCloseResponse(::google::protobuf::Arena* arena); + RpcCloseResponse(::google::protobuf::Arena* arena, const RpcCloseResponse& from); + RpcCloseResponse(::google::protobuf::Arena* arena, RpcCloseResponse&& from) noexcept + : RpcCloseResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:subspace.RpcCloseResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcCloseResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcCloseRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcCloseRequest) */ { + public: + inline RpcCloseRequest() : RpcCloseRequest(nullptr) {} + ~RpcCloseRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcCloseRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcCloseRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcCloseRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcCloseRequest(const RpcCloseRequest& from) : RpcCloseRequest(nullptr, from) {} + inline RpcCloseRequest(RpcCloseRequest&& from) noexcept + : RpcCloseRequest(nullptr, std::move(from)) {} + inline RpcCloseRequest& operator=(const RpcCloseRequest& from) { + CopyFrom(from); + return *this; + } + inline RpcCloseRequest& operator=(RpcCloseRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcCloseRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RpcCloseRequest* internal_default_instance() { + return reinterpret_cast( + &_RpcCloseRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 37; + friend void swap(RpcCloseRequest& a, RpcCloseRequest& b) { a.Swap(&b); } + inline void Swap(RpcCloseRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcCloseRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcCloseRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcCloseRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcCloseRequest& from) { RpcCloseRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcCloseRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcCloseRequest"; } + + protected: + explicit RpcCloseRequest(::google::protobuf::Arena* arena); + RpcCloseRequest(::google::protobuf::Arena* arena, const RpcCloseRequest& from); + RpcCloseRequest(::google::protobuf::Arena* arena, RpcCloseRequest&& from) noexcept + : RpcCloseRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSessionIdFieldNumber = 1, + }; + // int32 session_id = 1; + void clear_session_id() ; + ::int32_t session_id() const; + void set_session_id(::int32_t value); + + private: + ::int32_t _internal_session_id() const; + void _internal_set_session_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcCloseRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcCloseRequest& from_msg); + ::int32_t session_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcCancelRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcCancelRequest) */ { + public: + inline RpcCancelRequest() : RpcCancelRequest(nullptr) {} + ~RpcCancelRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcCancelRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcCancelRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcCancelRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcCancelRequest(const RpcCancelRequest& from) : RpcCancelRequest(nullptr, from) {} + inline RpcCancelRequest(RpcCancelRequest&& from) noexcept + : RpcCancelRequest(nullptr, std::move(from)) {} + inline RpcCancelRequest& operator=(const RpcCancelRequest& from) { + CopyFrom(from); + return *this; + } + inline RpcCancelRequest& operator=(RpcCancelRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcCancelRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RpcCancelRequest* internal_default_instance() { + return reinterpret_cast( + &_RpcCancelRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 43; + friend void swap(RpcCancelRequest& a, RpcCancelRequest& b) { a.Swap(&b); } + inline void Swap(RpcCancelRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcCancelRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcCancelRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcCancelRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcCancelRequest& from) { RpcCancelRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcCancelRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcCancelRequest"; } + + protected: + explicit RpcCancelRequest(::google::protobuf::Arena* arena); + RpcCancelRequest(::google::protobuf::Arena* arena, const RpcCancelRequest& from); + RpcCancelRequest(::google::protobuf::Arena* arena, RpcCancelRequest&& from) noexcept + : RpcCancelRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSessionIdFieldNumber = 1, + kRequestIdFieldNumber = 2, + kClientIdFieldNumber = 3, + }; + // int32 session_id = 1; + void clear_session_id() ; + ::int32_t session_id() const; + void set_session_id(::int32_t value); + + private: + ::int32_t _internal_session_id() const; + void _internal_set_session_id(::int32_t value); + + public: + // int32 request_id = 2; + void clear_request_id() ; + ::int32_t request_id() const; + void set_request_id(::int32_t value); + + private: + ::int32_t _internal_request_id() const; + void _internal_set_request_id(::int32_t value); + + public: + // uint64 client_id = 3; + void clear_client_id() ; + ::uint64_t client_id() const; + void set_client_id(::uint64_t value); + + private: + ::uint64_t _internal_client_id() const; + void _internal_set_client_id(::uint64_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcCancelRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcCancelRequest& from_msg); + ::int32_t session_id_; + ::int32_t request_id_; + ::uint64_t client_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RetirementNotification final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RetirementNotification) */ { + public: + inline RetirementNotification() : RetirementNotification(nullptr) {} + ~RetirementNotification() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RetirementNotification* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RetirementNotification)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RetirementNotification( + ::google::protobuf::internal::ConstantInitialized); + + inline RetirementNotification(const RetirementNotification& from) : RetirementNotification(nullptr, from) {} + inline RetirementNotification(RetirementNotification&& from) noexcept + : RetirementNotification(nullptr, std::move(from)) {} + inline RetirementNotification& operator=(const RetirementNotification& from) { + CopyFrom(from); + return *this; + } + inline RetirementNotification& operator=(RetirementNotification&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RetirementNotification& default_instance() { + return *internal_default_instance(); + } + static inline const RetirementNotification* internal_default_instance() { + return reinterpret_cast( + &_RetirementNotification_default_instance_); + } + static constexpr int kIndexInFileMessages = 27; + friend void swap(RetirementNotification& a, RetirementNotification& b) { a.Swap(&b); } + inline void Swap(RetirementNotification* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RetirementNotification* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RetirementNotification* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RetirementNotification& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RetirementNotification& from) { RetirementNotification::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RetirementNotification* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RetirementNotification"; } + + protected: + explicit RetirementNotification(::google::protobuf::Arena* arena); + RetirementNotification(::google::protobuf::Arena* arena, const RetirementNotification& from); + RetirementNotification(::google::protobuf::Arena* arena, RetirementNotification&& from) noexcept + : RetirementNotification(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSlotIdFieldNumber = 1, + }; + // int32 slot_id = 1; + void clear_slot_id() ; + ::int32_t slot_id() const; + void set_slot_id(::int32_t value); + + private: + ::int32_t _internal_slot_id() const; + void _internal_set_slot_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RetirementNotification) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RetirementNotification& from_msg); + ::int32_t slot_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RemoveSubscriberResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RemoveSubscriberResponse) */ { + public: + inline RemoveSubscriberResponse() : RemoveSubscriberResponse(nullptr) {} + ~RemoveSubscriberResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RemoveSubscriberResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RemoveSubscriberResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RemoveSubscriberResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline RemoveSubscriberResponse(const RemoveSubscriberResponse& from) : RemoveSubscriberResponse(nullptr, from) {} + inline RemoveSubscriberResponse(RemoveSubscriberResponse&& from) noexcept + : RemoveSubscriberResponse(nullptr, std::move(from)) {} + inline RemoveSubscriberResponse& operator=(const RemoveSubscriberResponse& from) { + CopyFrom(from); + return *this; + } + inline RemoveSubscriberResponse& operator=(RemoveSubscriberResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RemoveSubscriberResponse& default_instance() { + return *internal_default_instance(); + } + static inline const RemoveSubscriberResponse* internal_default_instance() { + return reinterpret_cast( + &_RemoveSubscriberResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 11; + friend void swap(RemoveSubscriberResponse& a, RemoveSubscriberResponse& b) { a.Swap(&b); } + inline void Swap(RemoveSubscriberResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RemoveSubscriberResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RemoveSubscriberResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RemoveSubscriberResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RemoveSubscriberResponse& from) { RemoveSubscriberResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RemoveSubscriberResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RemoveSubscriberResponse"; } + + protected: + explicit RemoveSubscriberResponse(::google::protobuf::Arena* arena); + RemoveSubscriberResponse(::google::protobuf::Arena* arena, const RemoveSubscriberResponse& from); + RemoveSubscriberResponse(::google::protobuf::Arena* arena, RemoveSubscriberResponse&& from) noexcept + : RemoveSubscriberResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kErrorFieldNumber = 1, + }; + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // @@protoc_insertion_point(class_scope:subspace.RemoveSubscriberResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 47, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RemoveSubscriberResponse& from_msg); + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RemoveSubscriberRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RemoveSubscriberRequest) */ { + public: + inline RemoveSubscriberRequest() : RemoveSubscriberRequest(nullptr) {} + ~RemoveSubscriberRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RemoveSubscriberRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RemoveSubscriberRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RemoveSubscriberRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RemoveSubscriberRequest(const RemoveSubscriberRequest& from) : RemoveSubscriberRequest(nullptr, from) {} + inline RemoveSubscriberRequest(RemoveSubscriberRequest&& from) noexcept + : RemoveSubscriberRequest(nullptr, std::move(from)) {} + inline RemoveSubscriberRequest& operator=(const RemoveSubscriberRequest& from) { + CopyFrom(from); + return *this; + } + inline RemoveSubscriberRequest& operator=(RemoveSubscriberRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RemoveSubscriberRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RemoveSubscriberRequest* internal_default_instance() { + return reinterpret_cast( + &_RemoveSubscriberRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 10; + friend void swap(RemoveSubscriberRequest& a, RemoveSubscriberRequest& b) { a.Swap(&b); } + inline void Swap(RemoveSubscriberRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RemoveSubscriberRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RemoveSubscriberRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RemoveSubscriberRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RemoveSubscriberRequest& from) { RemoveSubscriberRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RemoveSubscriberRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RemoveSubscriberRequest"; } + + protected: + explicit RemoveSubscriberRequest(::google::protobuf::Arena* arena); + RemoveSubscriberRequest(::google::protobuf::Arena* arena, const RemoveSubscriberRequest& from); + RemoveSubscriberRequest(::google::protobuf::Arena* arena, RemoveSubscriberRequest&& from) noexcept + : RemoveSubscriberRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kSubscriberIdFieldNumber = 2, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 subscriber_id = 2; + void clear_subscriber_id() ; + ::int32_t subscriber_id() const; + void set_subscriber_id(::int32_t value); + + private: + ::int32_t _internal_subscriber_id() const; + void _internal_set_subscriber_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RemoveSubscriberRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 53, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RemoveSubscriberRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t subscriber_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RemovePublisherResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RemovePublisherResponse) */ { + public: + inline RemovePublisherResponse() : RemovePublisherResponse(nullptr) {} + ~RemovePublisherResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RemovePublisherResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RemovePublisherResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RemovePublisherResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline RemovePublisherResponse(const RemovePublisherResponse& from) : RemovePublisherResponse(nullptr, from) {} + inline RemovePublisherResponse(RemovePublisherResponse&& from) noexcept + : RemovePublisherResponse(nullptr, std::move(from)) {} + inline RemovePublisherResponse& operator=(const RemovePublisherResponse& from) { + CopyFrom(from); + return *this; + } + inline RemovePublisherResponse& operator=(RemovePublisherResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RemovePublisherResponse& default_instance() { + return *internal_default_instance(); + } + static inline const RemovePublisherResponse* internal_default_instance() { + return reinterpret_cast( + &_RemovePublisherResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 9; + friend void swap(RemovePublisherResponse& a, RemovePublisherResponse& b) { a.Swap(&b); } + inline void Swap(RemovePublisherResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RemovePublisherResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RemovePublisherResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RemovePublisherResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RemovePublisherResponse& from) { RemovePublisherResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RemovePublisherResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RemovePublisherResponse"; } + + protected: + explicit RemovePublisherResponse(::google::protobuf::Arena* arena); + RemovePublisherResponse(::google::protobuf::Arena* arena, const RemovePublisherResponse& from); + RemovePublisherResponse(::google::protobuf::Arena* arena, RemovePublisherResponse&& from) noexcept + : RemovePublisherResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kErrorFieldNumber = 1, + }; + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // @@protoc_insertion_point(class_scope:subspace.RemovePublisherResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 46, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RemovePublisherResponse& from_msg); + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RemovePublisherRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RemovePublisherRequest) */ { + public: + inline RemovePublisherRequest() : RemovePublisherRequest(nullptr) {} + ~RemovePublisherRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RemovePublisherRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RemovePublisherRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RemovePublisherRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RemovePublisherRequest(const RemovePublisherRequest& from) : RemovePublisherRequest(nullptr, from) {} + inline RemovePublisherRequest(RemovePublisherRequest&& from) noexcept + : RemovePublisherRequest(nullptr, std::move(from)) {} + inline RemovePublisherRequest& operator=(const RemovePublisherRequest& from) { + CopyFrom(from); + return *this; + } + inline RemovePublisherRequest& operator=(RemovePublisherRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RemovePublisherRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RemovePublisherRequest* internal_default_instance() { + return reinterpret_cast( + &_RemovePublisherRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + friend void swap(RemovePublisherRequest& a, RemovePublisherRequest& b) { a.Swap(&b); } + inline void Swap(RemovePublisherRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RemovePublisherRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RemovePublisherRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RemovePublisherRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RemovePublisherRequest& from) { RemovePublisherRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RemovePublisherRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RemovePublisherRequest"; } + + protected: + explicit RemovePublisherRequest(::google::protobuf::Arena* arena); + RemovePublisherRequest(::google::protobuf::Arena* arena, const RemovePublisherRequest& from); + RemovePublisherRequest(::google::protobuf::Arena* arena, RemovePublisherRequest&& from) noexcept + : RemovePublisherRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kPublisherIdFieldNumber = 2, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int32 publisher_id = 2; + void clear_publisher_id() ; + ::int32_t publisher_id() const; + void set_publisher_id(::int32_t value); + + private: + ::int32_t _internal_publisher_id() const; + void _internal_set_publisher_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RemovePublisherRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 52, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RemovePublisherRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int32_t publisher_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RawMessage final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RawMessage) */ { + public: + inline RawMessage() : RawMessage(nullptr) {} + ~RawMessage() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RawMessage* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RawMessage)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RawMessage( + ::google::protobuf::internal::ConstantInitialized); + + inline RawMessage(const RawMessage& from) : RawMessage(nullptr, from) {} + inline RawMessage(RawMessage&& from) noexcept + : RawMessage(nullptr, std::move(from)) {} + inline RawMessage& operator=(const RawMessage& from) { + CopyFrom(from); + return *this; + } + inline RawMessage& operator=(RawMessage&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RawMessage& default_instance() { + return *internal_default_instance(); + } + static inline const RawMessage* internal_default_instance() { + return reinterpret_cast( + &_RawMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = 44; + friend void swap(RawMessage& a, RawMessage& b) { a.Swap(&b); } + inline void Swap(RawMessage* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RawMessage* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RawMessage* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RawMessage& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RawMessage& from) { RawMessage::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RawMessage* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RawMessage"; } + + protected: + explicit RawMessage(::google::protobuf::Arena* arena); + RawMessage(::google::protobuf::Arena* arena, const RawMessage& from); + RawMessage(::google::protobuf::Arena* arena, RawMessage&& from) noexcept + : RawMessage(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kDataFieldNumber = 1, + }; + // bytes data = 1; + void clear_data() ; + const std::string& data() const; + template + void set_data(Arg_&& arg, Args_... args); + std::string* mutable_data(); + PROTOBUF_NODISCARD std::string* release_data(); + void set_allocated_data(std::string* value); + + private: + const std::string& _internal_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( + const std::string& value); + std::string* _internal_mutable_data(); + + public: + // @@protoc_insertion_point(class_scope:subspace.RawMessage) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RawMessage& from_msg); + ::google::protobuf::internal::ArenaStringPtr data_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class InitResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.InitResponse) */ { + public: + inline InitResponse() : InitResponse(nullptr) {} + ~InitResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(InitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(InitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR InitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline InitResponse(const InitResponse& from) : InitResponse(nullptr, from) {} + inline InitResponse(InitResponse&& from) noexcept + : InitResponse(nullptr, std::move(from)) {} + inline InitResponse& operator=(const InitResponse& from) { + CopyFrom(from); + return *this; + } + inline InitResponse& operator=(InitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const InitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const InitResponse* internal_default_instance() { + return reinterpret_cast( + &_InitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(InitResponse& a, InitResponse& b) { a.Swap(&b); } + inline void Swap(InitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(InitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + InitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const InitResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const InitResponse& from) { InitResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(InitResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.InitResponse"; } + + protected: + explicit InitResponse(::google::protobuf::Arena* arena); + InitResponse(::google::protobuf::Arena* arena, const InitResponse& from); + InitResponse(::google::protobuf::Arena* arena, InitResponse&& from) noexcept + : InitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSessionIdFieldNumber = 2, + kScbFdIndexFieldNumber = 1, + kUserIdFieldNumber = 3, + kGroupIdFieldNumber = 4, + }; + // int64 session_id = 2; + void clear_session_id() ; + ::int64_t session_id() const; + void set_session_id(::int64_t value); + + private: + ::int64_t _internal_session_id() const; + void _internal_set_session_id(::int64_t value); + + public: + // int32 scb_fd_index = 1; + void clear_scb_fd_index() ; + ::int32_t scb_fd_index() const; + void set_scb_fd_index(::int32_t value); + + private: + ::int32_t _internal_scb_fd_index() const; + void _internal_set_scb_fd_index(::int32_t value); + + public: + // int32 user_id = 3; + void clear_user_id() ; + ::int32_t user_id() const; + void set_user_id(::int32_t value); + + private: + ::int32_t _internal_user_id() const; + void _internal_set_user_id(::int32_t value); + + public: + // int32 group_id = 4; + void clear_group_id() ; + ::int32_t group_id() const; + void set_group_id(::int32_t value); + + private: + ::int32_t _internal_group_id() const; + void _internal_set_group_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.InitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 4, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const InitResponse& from_msg); + ::int64_t session_id_; + ::int32_t scb_fd_index_; + ::int32_t user_id_; + ::int32_t group_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class InitRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.InitRequest) */ { + public: + inline InitRequest() : InitRequest(nullptr) {} + ~InitRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(InitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(InitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR InitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline InitRequest(const InitRequest& from) : InitRequest(nullptr, from) {} + inline InitRequest(InitRequest&& from) noexcept + : InitRequest(nullptr, std::move(from)) {} + inline InitRequest& operator=(const InitRequest& from) { + CopyFrom(from); + return *this; + } + inline InitRequest& operator=(InitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const InitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const InitRequest* internal_default_instance() { + return reinterpret_cast( + &_InitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(InitRequest& a, InitRequest& b) { a.Swap(&b); } + inline void Swap(InitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(InitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + InitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const InitRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const InitRequest& from) { InitRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(InitRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.InitRequest"; } + + protected: + explicit InitRequest(::google::protobuf::Arena* arena); + InitRequest(::google::protobuf::Arena* arena, const InitRequest& from); + InitRequest(::google::protobuf::Arena* arena, InitRequest&& from) noexcept + : InitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kClientNameFieldNumber = 1, + }; + // string client_name = 1; + void clear_client_name() ; + const std::string& client_name() const; + template + void set_client_name(Arg_&& arg, Args_... args); + std::string* mutable_client_name(); + PROTOBUF_NODISCARD std::string* release_client_name(); + void set_allocated_client_name(std::string* value); + + private: + const std::string& _internal_client_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_name( + const std::string& value); + std::string* _internal_mutable_client_name(); + + public: + // @@protoc_insertion_point(class_scope:subspace.InitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 40, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const InitRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr client_name_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class GetTriggersResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.GetTriggersResponse) */ { + public: + inline GetTriggersResponse() : GetTriggersResponse(nullptr) {} + ~GetTriggersResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetTriggersResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetTriggersResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetTriggersResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline GetTriggersResponse(const GetTriggersResponse& from) : GetTriggersResponse(nullptr, from) {} + inline GetTriggersResponse(GetTriggersResponse&& from) noexcept + : GetTriggersResponse(nullptr, std::move(from)) {} + inline GetTriggersResponse& operator=(const GetTriggersResponse& from) { + CopyFrom(from); + return *this; + } + inline GetTriggersResponse& operator=(GetTriggersResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GetTriggersResponse& default_instance() { + return *internal_default_instance(); + } + static inline const GetTriggersResponse* internal_default_instance() { + return reinterpret_cast( + &_GetTriggersResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 7; + friend void swap(GetTriggersResponse& a, GetTriggersResponse& b) { a.Swap(&b); } + inline void Swap(GetTriggersResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetTriggersResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetTriggersResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GetTriggersResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GetTriggersResponse& from) { GetTriggersResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetTriggersResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.GetTriggersResponse"; } + + protected: + explicit GetTriggersResponse(::google::protobuf::Arena* arena); + GetTriggersResponse(::google::protobuf::Arena* arena, const GetTriggersResponse& from); + GetTriggersResponse(::google::protobuf::Arena* arena, GetTriggersResponse&& from) noexcept + : GetTriggersResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kReliablePubTriggerFdIndexesFieldNumber = 2, + kSubTriggerFdIndexesFieldNumber = 3, + kRetirementFdIndexesFieldNumber = 4, + kErrorFieldNumber = 1, + }; + // repeated int32 reliable_pub_trigger_fd_indexes = 2; + int reliable_pub_trigger_fd_indexes_size() const; + private: + int _internal_reliable_pub_trigger_fd_indexes_size() const; + + public: + void clear_reliable_pub_trigger_fd_indexes() ; + ::int32_t reliable_pub_trigger_fd_indexes(int index) const; + void set_reliable_pub_trigger_fd_indexes(int index, ::int32_t value); + void add_reliable_pub_trigger_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& reliable_pub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_reliable_pub_trigger_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_reliable_pub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_reliable_pub_trigger_fd_indexes(); + + public: + // repeated int32 sub_trigger_fd_indexes = 3; + int sub_trigger_fd_indexes_size() const; + private: + int _internal_sub_trigger_fd_indexes_size() const; + + public: + void clear_sub_trigger_fd_indexes() ; + ::int32_t sub_trigger_fd_indexes(int index) const; + void set_sub_trigger_fd_indexes(int index, ::int32_t value); + void add_sub_trigger_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& sub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_sub_trigger_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_sub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_sub_trigger_fd_indexes(); + + public: + // repeated int32 retirement_fd_indexes = 4; + int retirement_fd_indexes_size() const; + private: + int _internal_retirement_fd_indexes_size() const; + + public: + void clear_retirement_fd_indexes() ; + ::int32_t retirement_fd_indexes(int index) const; + void set_retirement_fd_indexes(int index, ::int32_t value); + void add_retirement_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& retirement_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_retirement_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_retirement_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_retirement_fd_indexes(); + + public: + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // @@protoc_insertion_point(class_scope:subspace.GetTriggersResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 4, 0, + 42, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetTriggersResponse& from_msg); + ::google::protobuf::RepeatedField<::int32_t> reliable_pub_trigger_fd_indexes_; + ::google::protobuf::internal::CachedSize _reliable_pub_trigger_fd_indexes_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> sub_trigger_fd_indexes_; + ::google::protobuf::internal::CachedSize _sub_trigger_fd_indexes_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> retirement_fd_indexes_; + ::google::protobuf::internal::CachedSize _retirement_fd_indexes_cached_byte_size_; + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class GetTriggersRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.GetTriggersRequest) */ { + public: + inline GetTriggersRequest() : GetTriggersRequest(nullptr) {} + ~GetTriggersRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetTriggersRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetTriggersRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetTriggersRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline GetTriggersRequest(const GetTriggersRequest& from) : GetTriggersRequest(nullptr, from) {} + inline GetTriggersRequest(GetTriggersRequest&& from) noexcept + : GetTriggersRequest(nullptr, std::move(from)) {} + inline GetTriggersRequest& operator=(const GetTriggersRequest& from) { + CopyFrom(from); + return *this; + } + inline GetTriggersRequest& operator=(GetTriggersRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GetTriggersRequest& default_instance() { + return *internal_default_instance(); + } + static inline const GetTriggersRequest* internal_default_instance() { + return reinterpret_cast( + &_GetTriggersRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(GetTriggersRequest& a, GetTriggersRequest& b) { a.Swap(&b); } + inline void Swap(GetTriggersRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetTriggersRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetTriggersRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GetTriggersRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GetTriggersRequest& from) { GetTriggersRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetTriggersRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.GetTriggersRequest"; } + + protected: + explicit GetTriggersRequest(::google::protobuf::Arena* arena); + GetTriggersRequest(::google::protobuf::Arena* arena, const GetTriggersRequest& from); + GetTriggersRequest(::google::protobuf::Arena* arena, GetTriggersRequest&& from) noexcept + : GetTriggersRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // @@protoc_insertion_point(class_scope:subspace.GetTriggersRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 48, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetTriggersRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class GetChannelStatsRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.GetChannelStatsRequest) */ { + public: + inline GetChannelStatsRequest() : GetChannelStatsRequest(nullptr) {} + ~GetChannelStatsRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetChannelStatsRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetChannelStatsRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetChannelStatsRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline GetChannelStatsRequest(const GetChannelStatsRequest& from) : GetChannelStatsRequest(nullptr, from) {} + inline GetChannelStatsRequest(GetChannelStatsRequest&& from) noexcept + : GetChannelStatsRequest(nullptr, std::move(from)) {} + inline GetChannelStatsRequest& operator=(const GetChannelStatsRequest& from) { + CopyFrom(from); + return *this; + } + inline GetChannelStatsRequest& operator=(GetChannelStatsRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GetChannelStatsRequest& default_instance() { + return *internal_default_instance(); + } + static inline const GetChannelStatsRequest* internal_default_instance() { + return reinterpret_cast( + &_GetChannelStatsRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 14; + friend void swap(GetChannelStatsRequest& a, GetChannelStatsRequest& b) { a.Swap(&b); } + inline void Swap(GetChannelStatsRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetChannelStatsRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetChannelStatsRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GetChannelStatsRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GetChannelStatsRequest& from) { GetChannelStatsRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetChannelStatsRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.GetChannelStatsRequest"; } + + protected: + explicit GetChannelStatsRequest(::google::protobuf::Arena* arena); + GetChannelStatsRequest(::google::protobuf::Arena* arena, const GetChannelStatsRequest& from); + GetChannelStatsRequest(::google::protobuf::Arena* arena, GetChannelStatsRequest&& from) noexcept + : GetChannelStatsRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // @@protoc_insertion_point(class_scope:subspace.GetChannelStatsRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 52, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetChannelStatsRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class GetChannelInfoRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.GetChannelInfoRequest) */ { + public: + inline GetChannelInfoRequest() : GetChannelInfoRequest(nullptr) {} + ~GetChannelInfoRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetChannelInfoRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetChannelInfoRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetChannelInfoRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline GetChannelInfoRequest(const GetChannelInfoRequest& from) : GetChannelInfoRequest(nullptr, from) {} + inline GetChannelInfoRequest(GetChannelInfoRequest&& from) noexcept + : GetChannelInfoRequest(nullptr, std::move(from)) {} + inline GetChannelInfoRequest& operator=(const GetChannelInfoRequest& from) { + CopyFrom(from); + return *this; + } + inline GetChannelInfoRequest& operator=(GetChannelInfoRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GetChannelInfoRequest& default_instance() { + return *internal_default_instance(); + } + static inline const GetChannelInfoRequest* internal_default_instance() { + return reinterpret_cast( + &_GetChannelInfoRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 12; + friend void swap(GetChannelInfoRequest& a, GetChannelInfoRequest& b) { a.Swap(&b); } + inline void Swap(GetChannelInfoRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetChannelInfoRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetChannelInfoRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GetChannelInfoRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GetChannelInfoRequest& from) { GetChannelInfoRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetChannelInfoRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.GetChannelInfoRequest"; } + + protected: + explicit GetChannelInfoRequest(::google::protobuf::Arena* arena); + GetChannelInfoRequest(::google::protobuf::Arena* arena, const GetChannelInfoRequest& from); + GetChannelInfoRequest(::google::protobuf::Arena* arena, GetChannelInfoRequest&& from) noexcept + : GetChannelInfoRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // @@protoc_insertion_point(class_scope:subspace.GetChannelInfoRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 51, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetChannelInfoRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Discovery_Query final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Discovery.Query) */ { + public: + inline Discovery_Query() : Discovery_Query(nullptr) {} + ~Discovery_Query() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Discovery_Query* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Discovery_Query)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Discovery_Query( + ::google::protobuf::internal::ConstantInitialized); + + inline Discovery_Query(const Discovery_Query& from) : Discovery_Query(nullptr, from) {} + inline Discovery_Query(Discovery_Query&& from) noexcept + : Discovery_Query(nullptr, std::move(from)) {} + inline Discovery_Query& operator=(const Discovery_Query& from) { + CopyFrom(from); + return *this; + } + inline Discovery_Query& operator=(Discovery_Query&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Discovery_Query& default_instance() { + return *internal_default_instance(); + } + static inline const Discovery_Query* internal_default_instance() { + return reinterpret_cast( + &_Discovery_Query_default_instance_); + } + static constexpr int kIndexInFileMessages = 28; + friend void swap(Discovery_Query& a, Discovery_Query& b) { a.Swap(&b); } + inline void Swap(Discovery_Query* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Discovery_Query* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Discovery_Query* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Discovery_Query& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Discovery_Query& from) { Discovery_Query::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Discovery_Query* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Discovery.Query"; } + + protected: + explicit Discovery_Query(::google::protobuf::Arena* arena); + Discovery_Query(::google::protobuf::Arena* arena, const Discovery_Query& from); + Discovery_Query(::google::protobuf::Arena* arena, Discovery_Query&& from) noexcept + : Discovery_Query(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // @@protoc_insertion_point(class_scope:subspace.Discovery.Query) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 45, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Discovery_Query& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Discovery_Advertise final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Discovery.Advertise) */ { + public: + inline Discovery_Advertise() : Discovery_Advertise(nullptr) {} + ~Discovery_Advertise() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Discovery_Advertise* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Discovery_Advertise)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Discovery_Advertise( + ::google::protobuf::internal::ConstantInitialized); + + inline Discovery_Advertise(const Discovery_Advertise& from) : Discovery_Advertise(nullptr, from) {} + inline Discovery_Advertise(Discovery_Advertise&& from) noexcept + : Discovery_Advertise(nullptr, std::move(from)) {} + inline Discovery_Advertise& operator=(const Discovery_Advertise& from) { + CopyFrom(from); + return *this; + } + inline Discovery_Advertise& operator=(Discovery_Advertise&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Discovery_Advertise& default_instance() { + return *internal_default_instance(); + } + static inline const Discovery_Advertise* internal_default_instance() { + return reinterpret_cast( + &_Discovery_Advertise_default_instance_); + } + static constexpr int kIndexInFileMessages = 29; + friend void swap(Discovery_Advertise& a, Discovery_Advertise& b) { a.Swap(&b); } + inline void Swap(Discovery_Advertise* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Discovery_Advertise* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Discovery_Advertise* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Discovery_Advertise& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Discovery_Advertise& from) { Discovery_Advertise::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Discovery_Advertise* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Discovery.Advertise"; } + + protected: + explicit Discovery_Advertise(::google::protobuf::Arena* arena); + Discovery_Advertise(::google::protobuf::Arena* arena, const Discovery_Advertise& from); + Discovery_Advertise(::google::protobuf::Arena* arena, Discovery_Advertise&& from) noexcept + : Discovery_Advertise(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kReliableFieldNumber = 2, + kNotifyRetirementFieldNumber = 3, + kSplitBuffersFieldNumber = 4, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // bool reliable = 2; + void clear_reliable() ; + bool reliable() const; + void set_reliable(bool value); + + private: + bool _internal_reliable() const; + void _internal_set_reliable(bool value); + + public: + // bool notify_retirement = 3; + void clear_notify_retirement() ; + bool notify_retirement() const; + void set_notify_retirement(bool value); + + private: + bool _internal_notify_retirement() const; + void _internal_set_notify_retirement(bool value); + + public: + // bool split_buffers = 4; + void clear_split_buffers() ; + bool split_buffers() const; + void set_split_buffers(bool value); + + private: + bool _internal_split_buffers() const; + void _internal_set_split_buffers(bool value); + + public: + // @@protoc_insertion_point(class_scope:subspace.Discovery.Advertise) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 4, 0, + 49, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Discovery_Advertise& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + bool reliable_; + bool notify_retirement_; + bool split_buffers_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class CreateSubscriberResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.CreateSubscriberResponse) */ { + public: + inline CreateSubscriberResponse() : CreateSubscriberResponse(nullptr) {} + ~CreateSubscriberResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CreateSubscriberResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CreateSubscriberResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CreateSubscriberResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline CreateSubscriberResponse(const CreateSubscriberResponse& from) : CreateSubscriberResponse(nullptr, from) {} + inline CreateSubscriberResponse(CreateSubscriberResponse&& from) noexcept + : CreateSubscriberResponse(nullptr, std::move(from)) {} + inline CreateSubscriberResponse& operator=(const CreateSubscriberResponse& from) { + CopyFrom(from); + return *this; + } + inline CreateSubscriberResponse& operator=(CreateSubscriberResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CreateSubscriberResponse& default_instance() { + return *internal_default_instance(); + } + static inline const CreateSubscriberResponse* internal_default_instance() { + return reinterpret_cast( + &_CreateSubscriberResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 5; + friend void swap(CreateSubscriberResponse& a, CreateSubscriberResponse& b) { a.Swap(&b); } + inline void Swap(CreateSubscriberResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CreateSubscriberResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CreateSubscriberResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const CreateSubscriberResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const CreateSubscriberResponse& from) { CreateSubscriberResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CreateSubscriberResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.CreateSubscriberResponse"; } + + protected: + explicit CreateSubscriberResponse(::google::protobuf::Arena* arena); + CreateSubscriberResponse(::google::protobuf::Arena* arena, const CreateSubscriberResponse& from); + CreateSubscriberResponse(::google::protobuf::Arena* arena, CreateSubscriberResponse&& from) noexcept + : CreateSubscriberResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kReliablePubTriggerFdIndexesFieldNumber = 10, + kRetirementFdIndexesFieldNumber = 14, + kErrorFieldNumber = 1, + kTypeFieldNumber = 12, + kChannelIdFieldNumber = 2, + kSubscriberIdFieldNumber = 3, + kCcbFdIndexFieldNumber = 4, + kBcbFdIndexFieldNumber = 5, + kTriggerFdIndexFieldNumber = 6, + kPollFdIndexFieldNumber = 7, + kSlotSizeFieldNumber = 8, + kNumSlotsFieldNumber = 9, + kNumPubUpdatesFieldNumber = 11, + kVchanIdFieldNumber = 13, + kChecksumSizeFieldNumber = 15, + kMetadataSizeFieldNumber = 16, + kUseSplitBuffersFieldNumber = 17, + }; + // repeated int32 reliable_pub_trigger_fd_indexes = 10; + int reliable_pub_trigger_fd_indexes_size() const; + private: + int _internal_reliable_pub_trigger_fd_indexes_size() const; + + public: + void clear_reliable_pub_trigger_fd_indexes() ; + ::int32_t reliable_pub_trigger_fd_indexes(int index) const; + void set_reliable_pub_trigger_fd_indexes(int index, ::int32_t value); + void add_reliable_pub_trigger_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& reliable_pub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_reliable_pub_trigger_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_reliable_pub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_reliable_pub_trigger_fd_indexes(); + + public: + // repeated int32 retirement_fd_indexes = 14; + int retirement_fd_indexes_size() const; + private: + int _internal_retirement_fd_indexes_size() const; + + public: + void clear_retirement_fd_indexes() ; + ::int32_t retirement_fd_indexes(int index) const; + void set_retirement_fd_indexes(int index, ::int32_t value); + void add_retirement_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& retirement_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_retirement_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_retirement_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_retirement_fd_indexes(); + + public: + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // bytes type = 12; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // int32 channel_id = 2; + void clear_channel_id() ; + ::int32_t channel_id() const; + void set_channel_id(::int32_t value); + + private: + ::int32_t _internal_channel_id() const; + void _internal_set_channel_id(::int32_t value); + + public: + // int32 subscriber_id = 3; + void clear_subscriber_id() ; + ::int32_t subscriber_id() const; + void set_subscriber_id(::int32_t value); + + private: + ::int32_t _internal_subscriber_id() const; + void _internal_set_subscriber_id(::int32_t value); + + public: + // int32 ccb_fd_index = 4; + void clear_ccb_fd_index() ; + ::int32_t ccb_fd_index() const; + void set_ccb_fd_index(::int32_t value); + + private: + ::int32_t _internal_ccb_fd_index() const; + void _internal_set_ccb_fd_index(::int32_t value); + + public: + // int32 bcb_fd_index = 5; + void clear_bcb_fd_index() ; + ::int32_t bcb_fd_index() const; + void set_bcb_fd_index(::int32_t value); + + private: + ::int32_t _internal_bcb_fd_index() const; + void _internal_set_bcb_fd_index(::int32_t value); + + public: + // int32 trigger_fd_index = 6; + void clear_trigger_fd_index() ; + ::int32_t trigger_fd_index() const; + void set_trigger_fd_index(::int32_t value); + + private: + ::int32_t _internal_trigger_fd_index() const; + void _internal_set_trigger_fd_index(::int32_t value); + + public: + // int32 poll_fd_index = 7; + void clear_poll_fd_index() ; + ::int32_t poll_fd_index() const; + void set_poll_fd_index(::int32_t value); + + private: + ::int32_t _internal_poll_fd_index() const; + void _internal_set_poll_fd_index(::int32_t value); + + public: + // int32 slot_size = 8; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // int32 num_slots = 9; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // int32 num_pub_updates = 11; + void clear_num_pub_updates() ; + ::int32_t num_pub_updates() const; + void set_num_pub_updates(::int32_t value); + + private: + ::int32_t _internal_num_pub_updates() const; + void _internal_set_num_pub_updates(::int32_t value); + + public: + // int32 vchan_id = 13; + void clear_vchan_id() ; + ::int32_t vchan_id() const; + void set_vchan_id(::int32_t value); + + private: + ::int32_t _internal_vchan_id() const; + void _internal_set_vchan_id(::int32_t value); + + public: + // int32 checksum_size = 15; + void clear_checksum_size() ; + ::int32_t checksum_size() const; + void set_checksum_size(::int32_t value); + + private: + ::int32_t _internal_checksum_size() const; + void _internal_set_checksum_size(::int32_t value); + + public: + // int32 metadata_size = 16; + void clear_metadata_size() ; + ::int32_t metadata_size() const; + void set_metadata_size(::int32_t value); + + private: + ::int32_t _internal_metadata_size() const; + void _internal_set_metadata_size(::int32_t value); + + public: + // bool use_split_buffers = 17; + void clear_use_split_buffers() ; + bool use_split_buffers() const; + void set_use_split_buffers(bool value); + + private: + bool _internal_use_split_buffers() const; + void _internal_set_use_split_buffers(bool value); + + public: + // @@protoc_insertion_point(class_scope:subspace.CreateSubscriberResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 5, 17, 0, + 63, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CreateSubscriberResponse& from_msg); + ::google::protobuf::RepeatedField<::int32_t> reliable_pub_trigger_fd_indexes_; + ::google::protobuf::internal::CachedSize _reliable_pub_trigger_fd_indexes_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> retirement_fd_indexes_; + ::google::protobuf::internal::CachedSize _retirement_fd_indexes_cached_byte_size_; + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::int32_t channel_id_; + ::int32_t subscriber_id_; + ::int32_t ccb_fd_index_; + ::int32_t bcb_fd_index_; + ::int32_t trigger_fd_index_; + ::int32_t poll_fd_index_; + ::int32_t slot_size_; + ::int32_t num_slots_; + ::int32_t num_pub_updates_; + ::int32_t vchan_id_; + ::int32_t checksum_size_; + ::int32_t metadata_size_; + bool use_split_buffers_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class CreateSubscriberRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.CreateSubscriberRequest) */ { + public: + inline CreateSubscriberRequest() : CreateSubscriberRequest(nullptr) {} + ~CreateSubscriberRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CreateSubscriberRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CreateSubscriberRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CreateSubscriberRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline CreateSubscriberRequest(const CreateSubscriberRequest& from) : CreateSubscriberRequest(nullptr, from) {} + inline CreateSubscriberRequest(CreateSubscriberRequest&& from) noexcept + : CreateSubscriberRequest(nullptr, std::move(from)) {} + inline CreateSubscriberRequest& operator=(const CreateSubscriberRequest& from) { + CopyFrom(from); + return *this; + } + inline CreateSubscriberRequest& operator=(CreateSubscriberRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CreateSubscriberRequest& default_instance() { + return *internal_default_instance(); + } + static inline const CreateSubscriberRequest* internal_default_instance() { + return reinterpret_cast( + &_CreateSubscriberRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + friend void swap(CreateSubscriberRequest& a, CreateSubscriberRequest& b) { a.Swap(&b); } + inline void Swap(CreateSubscriberRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CreateSubscriberRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CreateSubscriberRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const CreateSubscriberRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const CreateSubscriberRequest& from) { CreateSubscriberRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CreateSubscriberRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.CreateSubscriberRequest"; } + + protected: + explicit CreateSubscriberRequest(::google::protobuf::Arena* arena); + CreateSubscriberRequest(::google::protobuf::Arena* arena, const CreateSubscriberRequest& from); + CreateSubscriberRequest(::google::protobuf::Arena* arena, CreateSubscriberRequest&& from) noexcept + : CreateSubscriberRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kTypeFieldNumber = 5, + kMuxFieldNumber = 7, + kSubscriberIdFieldNumber = 2, + kIsReliableFieldNumber = 3, + kIsBridgeFieldNumber = 4, + kForTunnelFieldNumber = 9, + kMaxActiveMessagesFieldNumber = 6, + kVchanIdFieldNumber = 8, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // bytes type = 5; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // string mux = 7; + void clear_mux() ; + const std::string& mux() const; + template + void set_mux(Arg_&& arg, Args_... args); + std::string* mutable_mux(); + PROTOBUF_NODISCARD std::string* release_mux(); + void set_allocated_mux(std::string* value); + + private: + const std::string& _internal_mux() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mux( + const std::string& value); + std::string* _internal_mutable_mux(); + + public: + // int32 subscriber_id = 2; + void clear_subscriber_id() ; + ::int32_t subscriber_id() const; + void set_subscriber_id(::int32_t value); + + private: + ::int32_t _internal_subscriber_id() const; + void _internal_set_subscriber_id(::int32_t value); + + public: + // bool is_reliable = 3; + void clear_is_reliable() ; + bool is_reliable() const; + void set_is_reliable(bool value); + + private: + bool _internal_is_reliable() const; + void _internal_set_is_reliable(bool value); + + public: + // bool is_bridge = 4; + void clear_is_bridge() ; + bool is_bridge() const; + void set_is_bridge(bool value); + + private: + bool _internal_is_bridge() const; + void _internal_set_is_bridge(bool value); + + public: + // bool for_tunnel = 9; + void clear_for_tunnel() ; + bool for_tunnel() const; + void set_for_tunnel(bool value); + + private: + bool _internal_for_tunnel() const; + void _internal_set_for_tunnel(bool value); + + public: + // int32 max_active_messages = 6; + void clear_max_active_messages() ; + ::int32_t max_active_messages() const; + void set_max_active_messages(::int32_t value); + + private: + ::int32_t _internal_max_active_messages() const; + void _internal_set_max_active_messages(::int32_t value); + + public: + // int32 vchan_id = 8; + void clear_vchan_id() ; + ::int32_t vchan_id() const; + void set_vchan_id(::int32_t value); + + private: + ::int32_t _internal_vchan_id() const; + void _internal_set_vchan_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.CreateSubscriberRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 9, 0, + 64, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CreateSubscriberRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::ArenaStringPtr mux_; + ::int32_t subscriber_id_; + bool is_reliable_; + bool is_bridge_; + bool for_tunnel_; + ::int32_t max_active_messages_; + ::int32_t vchan_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class CreatePublisherResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.CreatePublisherResponse) */ { + public: + inline CreatePublisherResponse() : CreatePublisherResponse(nullptr) {} + ~CreatePublisherResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CreatePublisherResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CreatePublisherResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CreatePublisherResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline CreatePublisherResponse(const CreatePublisherResponse& from) : CreatePublisherResponse(nullptr, from) {} + inline CreatePublisherResponse(CreatePublisherResponse&& from) noexcept + : CreatePublisherResponse(nullptr, std::move(from)) {} + inline CreatePublisherResponse& operator=(const CreatePublisherResponse& from) { + CopyFrom(from); + return *this; + } + inline CreatePublisherResponse& operator=(CreatePublisherResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CreatePublisherResponse& default_instance() { + return *internal_default_instance(); + } + static inline const CreatePublisherResponse* internal_default_instance() { + return reinterpret_cast( + &_CreatePublisherResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(CreatePublisherResponse& a, CreatePublisherResponse& b) { a.Swap(&b); } + inline void Swap(CreatePublisherResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CreatePublisherResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CreatePublisherResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const CreatePublisherResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const CreatePublisherResponse& from) { CreatePublisherResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CreatePublisherResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.CreatePublisherResponse"; } + + protected: + explicit CreatePublisherResponse(::google::protobuf::Arena* arena); + CreatePublisherResponse(::google::protobuf::Arena* arena, const CreatePublisherResponse& from); + CreatePublisherResponse(::google::protobuf::Arena* arena, CreatePublisherResponse&& from) noexcept + : CreatePublisherResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSubTriggerFdIndexesFieldNumber = 8, + kRetirementFdIndexesFieldNumber = 15, + kErrorFieldNumber = 1, + kTypeFieldNumber = 10, + kChannelIdFieldNumber = 2, + kPublisherIdFieldNumber = 3, + kCcbFdIndexFieldNumber = 4, + kBcbFdIndexFieldNumber = 5, + kPubPollFdIndexFieldNumber = 6, + kPubTriggerFdIndexFieldNumber = 7, + kNumSubUpdatesFieldNumber = 9, + kVchanIdFieldNumber = 11, + kRetirementFdIndexFieldNumber = 14, + }; + // repeated int32 sub_trigger_fd_indexes = 8; + int sub_trigger_fd_indexes_size() const; + private: + int _internal_sub_trigger_fd_indexes_size() const; + + public: + void clear_sub_trigger_fd_indexes() ; + ::int32_t sub_trigger_fd_indexes(int index) const; + void set_sub_trigger_fd_indexes(int index, ::int32_t value); + void add_sub_trigger_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& sub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_sub_trigger_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_sub_trigger_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_sub_trigger_fd_indexes(); + + public: + // repeated int32 retirement_fd_indexes = 15; + int retirement_fd_indexes_size() const; + private: + int _internal_retirement_fd_indexes_size() const; + + public: + void clear_retirement_fd_indexes() ; + ::int32_t retirement_fd_indexes(int index) const; + void set_retirement_fd_indexes(int index, ::int32_t value); + void add_retirement_fd_indexes(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& retirement_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_retirement_fd_indexes(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_retirement_fd_indexes() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_retirement_fd_indexes(); + + public: + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // bytes type = 10; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // int32 channel_id = 2; + void clear_channel_id() ; + ::int32_t channel_id() const; + void set_channel_id(::int32_t value); + + private: + ::int32_t _internal_channel_id() const; + void _internal_set_channel_id(::int32_t value); + + public: + // int32 publisher_id = 3; + void clear_publisher_id() ; + ::int32_t publisher_id() const; + void set_publisher_id(::int32_t value); + + private: + ::int32_t _internal_publisher_id() const; + void _internal_set_publisher_id(::int32_t value); + + public: + // int32 ccb_fd_index = 4; + void clear_ccb_fd_index() ; + ::int32_t ccb_fd_index() const; + void set_ccb_fd_index(::int32_t value); + + private: + ::int32_t _internal_ccb_fd_index() const; + void _internal_set_ccb_fd_index(::int32_t value); + + public: + // int32 bcb_fd_index = 5; + void clear_bcb_fd_index() ; + ::int32_t bcb_fd_index() const; + void set_bcb_fd_index(::int32_t value); + + private: + ::int32_t _internal_bcb_fd_index() const; + void _internal_set_bcb_fd_index(::int32_t value); + + public: + // int32 pub_poll_fd_index = 6; + void clear_pub_poll_fd_index() ; + ::int32_t pub_poll_fd_index() const; + void set_pub_poll_fd_index(::int32_t value); + + private: + ::int32_t _internal_pub_poll_fd_index() const; + void _internal_set_pub_poll_fd_index(::int32_t value); + + public: + // int32 pub_trigger_fd_index = 7; + void clear_pub_trigger_fd_index() ; + ::int32_t pub_trigger_fd_index() const; + void set_pub_trigger_fd_index(::int32_t value); + + private: + ::int32_t _internal_pub_trigger_fd_index() const; + void _internal_set_pub_trigger_fd_index(::int32_t value); + + public: + // int32 num_sub_updates = 9; + void clear_num_sub_updates() ; + ::int32_t num_sub_updates() const; + void set_num_sub_updates(::int32_t value); + + private: + ::int32_t _internal_num_sub_updates() const; + void _internal_set_num_sub_updates(::int32_t value); + + public: + // int32 vchan_id = 11; + void clear_vchan_id() ; + ::int32_t vchan_id() const; + void set_vchan_id(::int32_t value); + + private: + ::int32_t _internal_vchan_id() const; + void _internal_set_vchan_id(::int32_t value); + + public: + // int32 retirement_fd_index = 14; + void clear_retirement_fd_index() ; + ::int32_t retirement_fd_index() const; + void set_retirement_fd_index(::int32_t value); + + private: + ::int32_t _internal_retirement_fd_index() const; + void _internal_set_retirement_fd_index(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.CreatePublisherResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 13, 0, + 54, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CreatePublisherResponse& from_msg); + ::google::protobuf::RepeatedField<::int32_t> sub_trigger_fd_indexes_; + ::google::protobuf::internal::CachedSize _sub_trigger_fd_indexes_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> retirement_fd_indexes_; + ::google::protobuf::internal::CachedSize _retirement_fd_indexes_cached_byte_size_; + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::int32_t channel_id_; + ::int32_t publisher_id_; + ::int32_t ccb_fd_index_; + ::int32_t bcb_fd_index_; + ::int32_t pub_poll_fd_index_; + ::int32_t pub_trigger_fd_index_; + ::int32_t num_sub_updates_; + ::int32_t vchan_id_; + ::int32_t retirement_fd_index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class CreatePublisherRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.CreatePublisherRequest) */ { + public: + inline CreatePublisherRequest() : CreatePublisherRequest(nullptr) {} + ~CreatePublisherRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CreatePublisherRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CreatePublisherRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CreatePublisherRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline CreatePublisherRequest(const CreatePublisherRequest& from) : CreatePublisherRequest(nullptr, from) {} + inline CreatePublisherRequest(CreatePublisherRequest&& from) noexcept + : CreatePublisherRequest(nullptr, std::move(from)) {} + inline CreatePublisherRequest& operator=(const CreatePublisherRequest& from) { + CopyFrom(from); + return *this; + } + inline CreatePublisherRequest& operator=(CreatePublisherRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CreatePublisherRequest& default_instance() { + return *internal_default_instance(); + } + static inline const CreatePublisherRequest* internal_default_instance() { + return reinterpret_cast( + &_CreatePublisherRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(CreatePublisherRequest& a, CreatePublisherRequest& b) { a.Swap(&b); } + inline void Swap(CreatePublisherRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CreatePublisherRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CreatePublisherRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const CreatePublisherRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const CreatePublisherRequest& from) { CreatePublisherRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CreatePublisherRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.CreatePublisherRequest"; } + + protected: + explicit CreatePublisherRequest(::google::protobuf::Arena* arena); + CreatePublisherRequest(::google::protobuf::Arena* arena, const CreatePublisherRequest& from); + CreatePublisherRequest(::google::protobuf::Arena* arena, CreatePublisherRequest&& from) noexcept + : CreatePublisherRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kTypeFieldNumber = 7, + kMuxFieldNumber = 9, + kNumSlotsFieldNumber = 2, + kSlotSizeFieldNumber = 3, + kIsLocalFieldNumber = 4, + kIsReliableFieldNumber = 5, + kIsBridgeFieldNumber = 6, + kIsFixedSizeFieldNumber = 8, + kVchanIdFieldNumber = 10, + kChecksumSizeFieldNumber = 12, + kMetadataSizeFieldNumber = 13, + kPublisherIdFieldNumber = 14, + kForTunnelFieldNumber = 15, + kNotifyRetirementFieldNumber = 11, + kUseSplitBuffersFieldNumber = 16, + kSplitBuffersOverBridgeFieldNumber = 18, + kMaxPublishersFieldNumber = 17, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // bytes type = 7; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // string mux = 9; + void clear_mux() ; + const std::string& mux() const; + template + void set_mux(Arg_&& arg, Args_... args); + std::string* mutable_mux(); + PROTOBUF_NODISCARD std::string* release_mux(); + void set_allocated_mux(std::string* value); + + private: + const std::string& _internal_mux() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mux( + const std::string& value); + std::string* _internal_mutable_mux(); + + public: + // int32 num_slots = 2; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // int32 slot_size = 3; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // bool is_local = 4; + void clear_is_local() ; + bool is_local() const; + void set_is_local(bool value); + + private: + bool _internal_is_local() const; + void _internal_set_is_local(bool value); + + public: + // bool is_reliable = 5; + void clear_is_reliable() ; + bool is_reliable() const; + void set_is_reliable(bool value); + + private: + bool _internal_is_reliable() const; + void _internal_set_is_reliable(bool value); + + public: + // bool is_bridge = 6; + void clear_is_bridge() ; + bool is_bridge() const; + void set_is_bridge(bool value); + + private: + bool _internal_is_bridge() const; + void _internal_set_is_bridge(bool value); + + public: + // bool is_fixed_size = 8; + void clear_is_fixed_size() ; + bool is_fixed_size() const; + void set_is_fixed_size(bool value); + + private: + bool _internal_is_fixed_size() const; + void _internal_set_is_fixed_size(bool value); + + public: + // int32 vchan_id = 10; + void clear_vchan_id() ; + ::int32_t vchan_id() const; + void set_vchan_id(::int32_t value); + + private: + ::int32_t _internal_vchan_id() const; + void _internal_set_vchan_id(::int32_t value); + + public: + // int32 checksum_size = 12; + void clear_checksum_size() ; + ::int32_t checksum_size() const; + void set_checksum_size(::int32_t value); + + private: + ::int32_t _internal_checksum_size() const; + void _internal_set_checksum_size(::int32_t value); + + public: + // int32 metadata_size = 13; + void clear_metadata_size() ; + ::int32_t metadata_size() const; + void set_metadata_size(::int32_t value); + + private: + ::int32_t _internal_metadata_size() const; + void _internal_set_metadata_size(::int32_t value); + + public: + // int32 publisher_id = 14; + void clear_publisher_id() ; + ::int32_t publisher_id() const; + void set_publisher_id(::int32_t value); + + private: + ::int32_t _internal_publisher_id() const; + void _internal_set_publisher_id(::int32_t value); + + public: + // bool for_tunnel = 15; + void clear_for_tunnel() ; + bool for_tunnel() const; + void set_for_tunnel(bool value); + + private: + bool _internal_for_tunnel() const; + void _internal_set_for_tunnel(bool value); + + public: + // bool notify_retirement = 11; + void clear_notify_retirement() ; + bool notify_retirement() const; + void set_notify_retirement(bool value); + + private: + bool _internal_notify_retirement() const; + void _internal_set_notify_retirement(bool value); + + public: + // bool use_split_buffers = 16; + void clear_use_split_buffers() ; + bool use_split_buffers() const; + void set_use_split_buffers(bool value); + + private: + bool _internal_use_split_buffers() const; + void _internal_set_use_split_buffers(bool value); + + public: + // bool split_buffers_over_bridge = 18; + void clear_split_buffers_over_bridge() ; + bool split_buffers_over_bridge() const; + void set_split_buffers_over_bridge(bool value); + + private: + bool _internal_split_buffers_over_bridge() const; + void _internal_set_split_buffers_over_bridge(bool value); + + public: + // int32 max_publishers = 17; + void clear_max_publishers() ; + ::int32_t max_publishers() const; + void set_max_publishers(::int32_t value); + + private: + ::int32_t _internal_max_publishers() const; + void _internal_set_max_publishers(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.CreatePublisherRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 5, 18, 0, + 71, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CreatePublisherRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::ArenaStringPtr mux_; + ::int32_t num_slots_; + ::int32_t slot_size_; + bool is_local_; + bool is_reliable_; + bool is_bridge_; + bool is_fixed_size_; + ::int32_t vchan_id_; + ::int32_t checksum_size_; + ::int32_t metadata_size_; + ::int32_t publisher_id_; + bool for_tunnel_; + bool notify_retirement_; + bool use_split_buffers_; + bool split_buffers_over_bridge_; + ::int32_t max_publishers_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ChannelStatsProto final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ChannelStatsProto) */ { + public: + inline ChannelStatsProto() : ChannelStatsProto(nullptr) {} + ~ChannelStatsProto() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ChannelStatsProto* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ChannelStatsProto)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ChannelStatsProto( + ::google::protobuf::internal::ConstantInitialized); + + inline ChannelStatsProto(const ChannelStatsProto& from) : ChannelStatsProto(nullptr, from) {} + inline ChannelStatsProto(ChannelStatsProto&& from) noexcept + : ChannelStatsProto(nullptr, std::move(from)) {} + inline ChannelStatsProto& operator=(const ChannelStatsProto& from) { + CopyFrom(from); + return *this; + } + inline ChannelStatsProto& operator=(ChannelStatsProto&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ChannelStatsProto& default_instance() { + return *internal_default_instance(); + } + static inline const ChannelStatsProto* internal_default_instance() { + return reinterpret_cast( + &_ChannelStatsProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 23; + friend void swap(ChannelStatsProto& a, ChannelStatsProto& b) { a.Swap(&b); } + inline void Swap(ChannelStatsProto* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChannelStatsProto* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChannelStatsProto* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ChannelStatsProto& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ChannelStatsProto& from) { ChannelStatsProto::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ChannelStatsProto* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ChannelStatsProto"; } + + protected: + explicit ChannelStatsProto(::google::protobuf::Arena* arena); + ChannelStatsProto(::google::protobuf::Arena* arena, const ChannelStatsProto& from); + ChannelStatsProto(::google::protobuf::Arena* arena, ChannelStatsProto&& from) noexcept + : ChannelStatsProto(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kTotalBytesFieldNumber = 2, + kTotalMessagesFieldNumber = 3, + kSlotSizeFieldNumber = 4, + kNumSlotsFieldNumber = 5, + kNumPubsFieldNumber = 6, + kNumSubsFieldNumber = 7, + kMaxMessageSizeFieldNumber = 8, + kTotalDropsFieldNumber = 9, + kNumBridgePubsFieldNumber = 10, + kNumBridgeSubsFieldNumber = 11, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // int64 total_bytes = 2; + void clear_total_bytes() ; + ::int64_t total_bytes() const; + void set_total_bytes(::int64_t value); + + private: + ::int64_t _internal_total_bytes() const; + void _internal_set_total_bytes(::int64_t value); + + public: + // int64 total_messages = 3; + void clear_total_messages() ; + ::int64_t total_messages() const; + void set_total_messages(::int64_t value); + + private: + ::int64_t _internal_total_messages() const; + void _internal_set_total_messages(::int64_t value); + + public: + // int32 slot_size = 4; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // int32 num_slots = 5; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // int32 num_pubs = 6; + void clear_num_pubs() ; + ::int32_t num_pubs() const; + void set_num_pubs(::int32_t value); + + private: + ::int32_t _internal_num_pubs() const; + void _internal_set_num_pubs(::int32_t value); + + public: + // int32 num_subs = 7; + void clear_num_subs() ; + ::int32_t num_subs() const; + void set_num_subs(::int32_t value); + + private: + ::int32_t _internal_num_subs() const; + void _internal_set_num_subs(::int32_t value); + + public: + // uint32 max_message_size = 8; + void clear_max_message_size() ; + ::uint32_t max_message_size() const; + void set_max_message_size(::uint32_t value); + + private: + ::uint32_t _internal_max_message_size() const; + void _internal_set_max_message_size(::uint32_t value); + + public: + // uint32 total_drops = 9; + void clear_total_drops() ; + ::uint32_t total_drops() const; + void set_total_drops(::uint32_t value); + + private: + ::uint32_t _internal_total_drops() const; + void _internal_set_total_drops(::uint32_t value); + + public: + // int32 num_bridge_pubs = 10; + void clear_num_bridge_pubs() ; + ::int32_t num_bridge_pubs() const; + void set_num_bridge_pubs(::int32_t value); + + private: + ::int32_t _internal_num_bridge_pubs() const; + void _internal_set_num_bridge_pubs(::int32_t value); + + public: + // int32 num_bridge_subs = 11; + void clear_num_bridge_subs() ; + ::int32_t num_bridge_subs() const; + void set_num_bridge_subs(::int32_t value); + + private: + ::int32_t _internal_num_bridge_subs() const; + void _internal_set_num_bridge_subs(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ChannelStatsProto) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 11, 0, + 55, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ChannelStatsProto& from_msg); + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::int64_t total_bytes_; + ::int64_t total_messages_; + ::int32_t slot_size_; + ::int32_t num_slots_; + ::int32_t num_pubs_; + ::int32_t num_subs_; + ::uint32_t max_message_size_; + ::uint32_t total_drops_; + ::int32_t num_bridge_pubs_; + ::int32_t num_bridge_subs_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ChannelInfoProto final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ChannelInfoProto) */ { + public: + inline ChannelInfoProto() : ChannelInfoProto(nullptr) {} + ~ChannelInfoProto() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ChannelInfoProto* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ChannelInfoProto)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ChannelInfoProto( + ::google::protobuf::internal::ConstantInitialized); + + inline ChannelInfoProto(const ChannelInfoProto& from) : ChannelInfoProto(nullptr, from) {} + inline ChannelInfoProto(ChannelInfoProto&& from) noexcept + : ChannelInfoProto(nullptr, std::move(from)) {} + inline ChannelInfoProto& operator=(const ChannelInfoProto& from) { + CopyFrom(from); + return *this; + } + inline ChannelInfoProto& operator=(ChannelInfoProto&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ChannelInfoProto& default_instance() { + return *internal_default_instance(); + } + static inline const ChannelInfoProto* internal_default_instance() { + return reinterpret_cast( + &_ChannelInfoProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 21; + friend void swap(ChannelInfoProto& a, ChannelInfoProto& b) { a.Swap(&b); } + inline void Swap(ChannelInfoProto* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChannelInfoProto* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChannelInfoProto* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ChannelInfoProto& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ChannelInfoProto& from) { ChannelInfoProto::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ChannelInfoProto* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ChannelInfoProto"; } + + protected: + explicit ChannelInfoProto(::google::protobuf::Arena* arena); + ChannelInfoProto(::google::protobuf::Arena* arena, const ChannelInfoProto& from); + ChannelInfoProto(::google::protobuf::Arena* arena, ChannelInfoProto&& from) noexcept + : ChannelInfoProto(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kNameFieldNumber = 1, + kTypeFieldNumber = 4, + kMuxFieldNumber = 12, + kSlotSizeFieldNumber = 2, + kNumSlotsFieldNumber = 3, + kNumPubsFieldNumber = 5, + kNumSubsFieldNumber = 6, + kNumBridgePubsFieldNumber = 7, + kNumBridgeSubsFieldNumber = 8, + kIsReliableFieldNumber = 9, + kIsVirtualFieldNumber = 10, + kVchanIdFieldNumber = 11, + kNumTunnelPubsFieldNumber = 13, + kNumTunnelSubsFieldNumber = 14, + }; + // string name = 1; + void clear_name() ; + const std::string& name() const; + template + void set_name(Arg_&& arg, Args_... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* value); + + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( + const std::string& value); + std::string* _internal_mutable_name(); + + public: + // bytes type = 4; + void clear_type() ; + const std::string& type() const; + template + void set_type(Arg_&& arg, Args_... args); + std::string* mutable_type(); + PROTOBUF_NODISCARD std::string* release_type(); + void set_allocated_type(std::string* value); + + private: + const std::string& _internal_type() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type( + const std::string& value); + std::string* _internal_mutable_type(); + + public: + // string mux = 12; + void clear_mux() ; + const std::string& mux() const; + template + void set_mux(Arg_&& arg, Args_... args); + std::string* mutable_mux(); + PROTOBUF_NODISCARD std::string* release_mux(); + void set_allocated_mux(std::string* value); + + private: + const std::string& _internal_mux() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mux( + const std::string& value); + std::string* _internal_mutable_mux(); + + public: + // int32 slot_size = 2; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // int32 num_slots = 3; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // int32 num_pubs = 5; + void clear_num_pubs() ; + ::int32_t num_pubs() const; + void set_num_pubs(::int32_t value); + + private: + ::int32_t _internal_num_pubs() const; + void _internal_set_num_pubs(::int32_t value); + + public: + // int32 num_subs = 6; + void clear_num_subs() ; + ::int32_t num_subs() const; + void set_num_subs(::int32_t value); + + private: + ::int32_t _internal_num_subs() const; + void _internal_set_num_subs(::int32_t value); + + public: + // int32 num_bridge_pubs = 7; + void clear_num_bridge_pubs() ; + ::int32_t num_bridge_pubs() const; + void set_num_bridge_pubs(::int32_t value); + + private: + ::int32_t _internal_num_bridge_pubs() const; + void _internal_set_num_bridge_pubs(::int32_t value); + + public: + // int32 num_bridge_subs = 8; + void clear_num_bridge_subs() ; + ::int32_t num_bridge_subs() const; + void set_num_bridge_subs(::int32_t value); + + private: + ::int32_t _internal_num_bridge_subs() const; + void _internal_set_num_bridge_subs(::int32_t value); + + public: + // bool is_reliable = 9; + void clear_is_reliable() ; + bool is_reliable() const; + void set_is_reliable(bool value); + + private: + bool _internal_is_reliable() const; + void _internal_set_is_reliable(bool value); + + public: + // bool is_virtual = 10; + void clear_is_virtual() ; + bool is_virtual() const; + void set_is_virtual(bool value); + + private: + bool _internal_is_virtual() const; + void _internal_set_is_virtual(bool value); + + public: + // int32 vchan_id = 11; + void clear_vchan_id() ; + ::int32_t vchan_id() const; + void set_vchan_id(::int32_t value); + + private: + ::int32_t _internal_vchan_id() const; + void _internal_set_vchan_id(::int32_t value); + + public: + // int32 num_tunnel_pubs = 13; + void clear_num_tunnel_pubs() ; + ::int32_t num_tunnel_pubs() const; + void set_num_tunnel_pubs(::int32_t value); + + private: + ::int32_t _internal_num_tunnel_pubs() const; + void _internal_set_num_tunnel_pubs(::int32_t value); + + public: + // int32 num_tunnel_subs = 14; + void clear_num_tunnel_subs() ; + ::int32_t num_tunnel_subs() const; + void set_num_tunnel_subs(::int32_t value); + + private: + ::int32_t _internal_num_tunnel_subs() const; + void _internal_set_num_tunnel_subs(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ChannelInfoProto) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 14, 0, + 49, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ChannelInfoProto& from_msg); + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr type_; + ::google::protobuf::internal::ArenaStringPtr mux_; + ::int32_t slot_size_; + ::int32_t num_slots_; + ::int32_t num_pubs_; + ::int32_t num_subs_; + ::int32_t num_bridge_pubs_; + ::int32_t num_bridge_subs_; + bool is_reliable_; + bool is_virtual_; + ::int32_t vchan_id_; + ::int32_t num_tunnel_pubs_; + ::int32_t num_tunnel_subs_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ChannelAddress final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ChannelAddress) */ { + public: + inline ChannelAddress() : ChannelAddress(nullptr) {} + ~ChannelAddress() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ChannelAddress* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ChannelAddress)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ChannelAddress( + ::google::protobuf::internal::ConstantInitialized); + + inline ChannelAddress(const ChannelAddress& from) : ChannelAddress(nullptr, from) {} + inline ChannelAddress(ChannelAddress&& from) noexcept + : ChannelAddress(nullptr, std::move(from)) {} + inline ChannelAddress& operator=(const ChannelAddress& from) { + CopyFrom(from); + return *this; + } + inline ChannelAddress& operator=(ChannelAddress&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ChannelAddress& default_instance() { + return *internal_default_instance(); + } + static inline const ChannelAddress* internal_default_instance() { + return reinterpret_cast( + &_ChannelAddress_default_instance_); + } + static constexpr int kIndexInFileMessages = 25; + friend void swap(ChannelAddress& a, ChannelAddress& b) { a.Swap(&b); } + inline void Swap(ChannelAddress* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChannelAddress* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChannelAddress* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ChannelAddress& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ChannelAddress& from) { ChannelAddress::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ChannelAddress* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ChannelAddress"; } + + protected: + explicit ChannelAddress(::google::protobuf::Arena* arena); + ChannelAddress(::google::protobuf::Arena* arena, const ChannelAddress& from); + ChannelAddress(::google::protobuf::Arena* arena, ChannelAddress&& from) noexcept + : ChannelAddress(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kAddressFieldNumber = 1, + kPortFieldNumber = 2, + }; + // bytes address = 1; + void clear_address() ; + const std::string& address() const; + template + void set_address(Arg_&& arg, Args_... args); + std::string* mutable_address(); + PROTOBUF_NODISCARD std::string* release_address(); + void set_allocated_address(std::string* value); + + private: + const std::string& _internal_address() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_address( + const std::string& value); + std::string* _internal_mutable_address(); + + public: + // int32 port = 2; + void clear_port() ; + ::int32_t port() const; + void set_port(::int32_t value); + + private: + ::int32_t _internal_port() const; + void _internal_set_port(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ChannelAddress) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ChannelAddress& from_msg); + ::google::protobuf::internal::ArenaStringPtr address_; + ::int32_t port_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Subscribed final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Subscribed) */ { + public: + inline Subscribed() : Subscribed(nullptr) {} + ~Subscribed() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Subscribed* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Subscribed)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Subscribed( + ::google::protobuf::internal::ConstantInitialized); + + inline Subscribed(const Subscribed& from) : Subscribed(nullptr, from) {} + inline Subscribed(Subscribed&& from) noexcept + : Subscribed(nullptr, std::move(from)) {} + inline Subscribed& operator=(const Subscribed& from) { + CopyFrom(from); + return *this; + } + inline Subscribed& operator=(Subscribed&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Subscribed& default_instance() { + return *internal_default_instance(); + } + static inline const Subscribed* internal_default_instance() { + return reinterpret_cast( + &_Subscribed_default_instance_); + } + static constexpr int kIndexInFileMessages = 26; + friend void swap(Subscribed& a, Subscribed& b) { a.Swap(&b); } + inline void Swap(Subscribed* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Subscribed* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Subscribed* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Subscribed& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Subscribed& from) { Subscribed::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Subscribed* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Subscribed"; } + + protected: + explicit Subscribed(::google::protobuf::Arena* arena); + Subscribed(::google::protobuf::Arena* arena, const Subscribed& from); + Subscribed(::google::protobuf::Arena* arena, Subscribed&& from) noexcept + : Subscribed(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kRetirementSocketFieldNumber = 6, + kSlotSizeFieldNumber = 2, + kNumSlotsFieldNumber = 3, + kChecksumSizeFieldNumber = 7, + kReliableFieldNumber = 4, + kNotifyRetirementFieldNumber = 5, + kSplitBuffersFieldNumber = 9, + kSplitBuffersOverBridgeFieldNumber = 10, + kMetadataSizeFieldNumber = 8, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // .subspace.ChannelAddress retirement_socket = 6; + bool has_retirement_socket() const; + void clear_retirement_socket() ; + const ::subspace::ChannelAddress& retirement_socket() const; + PROTOBUF_NODISCARD ::subspace::ChannelAddress* release_retirement_socket(); + ::subspace::ChannelAddress* mutable_retirement_socket(); + void set_allocated_retirement_socket(::subspace::ChannelAddress* value); + void unsafe_arena_set_allocated_retirement_socket(::subspace::ChannelAddress* value); + ::subspace::ChannelAddress* unsafe_arena_release_retirement_socket(); + + private: + const ::subspace::ChannelAddress& _internal_retirement_socket() const; + ::subspace::ChannelAddress* _internal_mutable_retirement_socket(); + + public: + // int32 slot_size = 2; + void clear_slot_size() ; + ::int32_t slot_size() const; + void set_slot_size(::int32_t value); + + private: + ::int32_t _internal_slot_size() const; + void _internal_set_slot_size(::int32_t value); + + public: + // int32 num_slots = 3; + void clear_num_slots() ; + ::int32_t num_slots() const; + void set_num_slots(::int32_t value); + + private: + ::int32_t _internal_num_slots() const; + void _internal_set_num_slots(::int32_t value); + + public: + // int32 checksum_size = 7; + void clear_checksum_size() ; + ::int32_t checksum_size() const; + void set_checksum_size(::int32_t value); + + private: + ::int32_t _internal_checksum_size() const; + void _internal_set_checksum_size(::int32_t value); + + public: + // bool reliable = 4; + void clear_reliable() ; + bool reliable() const; + void set_reliable(bool value); + + private: + bool _internal_reliable() const; + void _internal_set_reliable(bool value); + + public: + // bool notify_retirement = 5; + void clear_notify_retirement() ; + bool notify_retirement() const; + void set_notify_retirement(bool value); + + private: + bool _internal_notify_retirement() const; + void _internal_set_notify_retirement(bool value); + + public: + // bool split_buffers = 9; + void clear_split_buffers() ; + bool split_buffers() const; + void set_split_buffers(bool value); + + private: + bool _internal_split_buffers() const; + void _internal_set_split_buffers(bool value); + + public: + // bool split_buffers_over_bridge = 10; + void clear_split_buffers_over_bridge() ; + bool split_buffers_over_bridge() const; + void set_split_buffers_over_bridge(bool value); + + private: + bool _internal_split_buffers_over_bridge() const; + void _internal_set_split_buffers_over_bridge(bool value); + + public: + // int32 metadata_size = 8; + void clear_metadata_size() ; + ::int32_t metadata_size() const; + void set_metadata_size(::int32_t value); + + private: + ::int32_t _internal_metadata_size() const; + void _internal_set_metadata_size(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.Subscribed) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 10, 1, + 48, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Subscribed& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::subspace::ChannelAddress* retirement_socket_; + ::int32_t slot_size_; + ::int32_t num_slots_; + ::int32_t checksum_size_; + bool reliable_; + bool notify_retirement_; + bool split_buffers_; + bool split_buffers_over_bridge_; + ::int32_t metadata_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Statistics final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Statistics) */ { + public: + inline Statistics() : Statistics(nullptr) {} + ~Statistics() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Statistics* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Statistics)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Statistics( + ::google::protobuf::internal::ConstantInitialized); + + inline Statistics(const Statistics& from) : Statistics(nullptr, from) {} + inline Statistics(Statistics&& from) noexcept + : Statistics(nullptr, std::move(from)) {} + inline Statistics& operator=(const Statistics& from) { + CopyFrom(from); + return *this; + } + inline Statistics& operator=(Statistics&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Statistics& default_instance() { + return *internal_default_instance(); + } + static inline const Statistics* internal_default_instance() { + return reinterpret_cast( + &_Statistics_default_instance_); + } + static constexpr int kIndexInFileMessages = 24; + friend void swap(Statistics& a, Statistics& b) { a.Swap(&b); } + inline void Swap(Statistics* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Statistics* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Statistics* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Statistics& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Statistics& from) { Statistics::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Statistics* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Statistics"; } + + protected: + explicit Statistics(::google::protobuf::Arena* arena); + Statistics(::google::protobuf::Arena* arena, const Statistics& from); + Statistics(::google::protobuf::Arena* arena, Statistics&& from) noexcept + : Statistics(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelsFieldNumber = 3, + kServerIdFieldNumber = 1, + kTimestampFieldNumber = 2, + }; + // repeated .subspace.ChannelStatsProto channels = 3; + int channels_size() const; + private: + int _internal_channels_size() const; + + public: + void clear_channels() ; + ::subspace::ChannelStatsProto* mutable_channels(int index); + ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* mutable_channels(); + + private: + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& _internal_channels() const; + ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* _internal_mutable_channels(); + public: + const ::subspace::ChannelStatsProto& channels(int index) const; + ::subspace::ChannelStatsProto* add_channels(); + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& channels() const; + // string server_id = 1; + void clear_server_id() ; + const std::string& server_id() const; + template + void set_server_id(Arg_&& arg, Args_... args); + std::string* mutable_server_id(); + PROTOBUF_NODISCARD std::string* release_server_id(); + void set_allocated_server_id(std::string* value); + + private: + const std::string& _internal_server_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id( + const std::string& value); + std::string* _internal_mutable_server_id(); + + public: + // int64 timestamp = 2; + void clear_timestamp() ; + ::int64_t timestamp() const; + void set_timestamp(::int64_t value); + + private: + ::int64_t _internal_timestamp() const; + void _internal_set_timestamp(::int64_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.Statistics) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 1, + 37, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Statistics& from_msg); + ::google::protobuf::RepeatedPtrField< ::subspace::ChannelStatsProto > channels_; + ::google::protobuf::internal::ArenaStringPtr server_id_; + ::int64_t timestamp_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcServerRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcServerRequest) */ { + public: + inline RpcServerRequest() : RpcServerRequest(nullptr) {} + ~RpcServerRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcServerRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcServerRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcServerRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcServerRequest(const RpcServerRequest& from) : RpcServerRequest(nullptr, from) {} + inline RpcServerRequest(RpcServerRequest&& from) noexcept + : RpcServerRequest(nullptr, std::move(from)) {} + inline RpcServerRequest& operator=(const RpcServerRequest& from) { + CopyFrom(from); + return *this; + } + inline RpcServerRequest& operator=(RpcServerRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcServerRequest& default_instance() { + return *internal_default_instance(); + } + enum RequestCase { + kOpen = 3, + kClose = 4, + REQUEST_NOT_SET = 0, + }; + static inline const RpcServerRequest* internal_default_instance() { + return reinterpret_cast( + &_RpcServerRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 39; + friend void swap(RpcServerRequest& a, RpcServerRequest& b) { a.Swap(&b); } + inline void Swap(RpcServerRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcServerRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcServerRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcServerRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcServerRequest& from) { RpcServerRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcServerRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcServerRequest"; } + + protected: + explicit RpcServerRequest(::google::protobuf::Arena* arena); + RpcServerRequest(::google::protobuf::Arena* arena, const RpcServerRequest& from); + RpcServerRequest(::google::protobuf::Arena* arena, RpcServerRequest&& from) noexcept + : RpcServerRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kClientIdFieldNumber = 1, + kRequestIdFieldNumber = 2, + kOpenFieldNumber = 3, + kCloseFieldNumber = 4, + }; + // uint64 client_id = 1; + void clear_client_id() ; + ::uint64_t client_id() const; + void set_client_id(::uint64_t value); + + private: + ::uint64_t _internal_client_id() const; + void _internal_set_client_id(::uint64_t value); + + public: + // int32 request_id = 2; + void clear_request_id() ; + ::int32_t request_id() const; + void set_request_id(::int32_t value); + + private: + ::int32_t _internal_request_id() const; + void _internal_set_request_id(::int32_t value); + + public: + // .subspace.RpcOpenRequest open = 3; + bool has_open() const; + private: + bool _internal_has_open() const; + + public: + void clear_open() ; + const ::subspace::RpcOpenRequest& open() const; + PROTOBUF_NODISCARD ::subspace::RpcOpenRequest* release_open(); + ::subspace::RpcOpenRequest* mutable_open(); + void set_allocated_open(::subspace::RpcOpenRequest* value); + void unsafe_arena_set_allocated_open(::subspace::RpcOpenRequest* value); + ::subspace::RpcOpenRequest* unsafe_arena_release_open(); + + private: + const ::subspace::RpcOpenRequest& _internal_open() const; + ::subspace::RpcOpenRequest* _internal_mutable_open(); + + public: + // .subspace.RpcCloseRequest close = 4; + bool has_close() const; + private: + bool _internal_has_close() const; + + public: + void clear_close() ; + const ::subspace::RpcCloseRequest& close() const; + PROTOBUF_NODISCARD ::subspace::RpcCloseRequest* release_close(); + ::subspace::RpcCloseRequest* mutable_close(); + void set_allocated_close(::subspace::RpcCloseRequest* value); + void unsafe_arena_set_allocated_close(::subspace::RpcCloseRequest* value); + ::subspace::RpcCloseRequest* unsafe_arena_release_close(); + + private: + const ::subspace::RpcCloseRequest& _internal_close() const; + ::subspace::RpcCloseRequest* _internal_mutable_close(); + + public: + void clear_request(); + RequestCase request_case() const; + // @@protoc_insertion_point(class_scope:subspace.RpcServerRequest) + private: + class _Internal; + void set_has_open(); + void set_has_close(); + inline bool has_request() const; + inline void clear_has_request(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 4, 2, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcServerRequest& from_msg); + ::uint64_t client_id_; + ::int32_t request_id_; + union RequestUnion { + constexpr RequestUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::subspace::RpcOpenRequest* open_; + ::subspace::RpcCloseRequest* close_; + } request_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcResponse) */ { + public: + inline RpcResponse() : RpcResponse(nullptr) {} + ~RpcResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcResponse(const RpcResponse& from) : RpcResponse(nullptr, from) {} + inline RpcResponse(RpcResponse&& from) noexcept + : RpcResponse(nullptr, std::move(from)) {} + inline RpcResponse& operator=(const RpcResponse& from) { + CopyFrom(from); + return *this; + } + inline RpcResponse& operator=(RpcResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcResponse& default_instance() { + return *internal_default_instance(); + } + static inline const RpcResponse* internal_default_instance() { + return reinterpret_cast( + &_RpcResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 42; + friend void swap(RpcResponse& a, RpcResponse& b) { a.Swap(&b); } + inline void Swap(RpcResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcResponse& from) { RpcResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcResponse"; } + + protected: + explicit RpcResponse(::google::protobuf::Arena* arena); + RpcResponse(::google::protobuf::Arena* arena, const RpcResponse& from); + RpcResponse(::google::protobuf::Arena* arena, RpcResponse&& from) noexcept + : RpcResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kErrorFieldNumber = 1, + kResultFieldNumber = 2, + kSessionIdFieldNumber = 3, + kRequestIdFieldNumber = 4, + kClientIdFieldNumber = 5, + kIsLastFieldNumber = 6, + kIsCancelledFieldNumber = 7, + }; + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // .google.protobuf.Any result = 2; + bool has_result() const; + void clear_result() ; + const ::google::protobuf::Any& result() const; + PROTOBUF_NODISCARD ::google::protobuf::Any* release_result(); + ::google::protobuf::Any* mutable_result(); + void set_allocated_result(::google::protobuf::Any* value); + void unsafe_arena_set_allocated_result(::google::protobuf::Any* value); + ::google::protobuf::Any* unsafe_arena_release_result(); + + private: + const ::google::protobuf::Any& _internal_result() const; + ::google::protobuf::Any* _internal_mutable_result(); + + public: + // int32 session_id = 3; + void clear_session_id() ; + ::int32_t session_id() const; + void set_session_id(::int32_t value); + + private: + ::int32_t _internal_session_id() const; + void _internal_set_session_id(::int32_t value); + + public: + // int32 request_id = 4; + void clear_request_id() ; + ::int32_t request_id() const; + void set_request_id(::int32_t value); + + private: + ::int32_t _internal_request_id() const; + void _internal_set_request_id(::int32_t value); + + public: + // uint64 client_id = 5; + void clear_client_id() ; + ::uint64_t client_id() const; + void set_client_id(::uint64_t value); + + private: + ::uint64_t _internal_client_id() const; + void _internal_set_client_id(::uint64_t value); + + public: + // bool is_last = 6; + void clear_is_last() ; + bool is_last() const; + void set_is_last(bool value); + + private: + bool _internal_is_last() const; + void _internal_set_is_last(bool value); + + public: + // bool is_cancelled = 7; + void clear_is_cancelled() ; + bool is_cancelled() const; + void set_is_cancelled(bool value); + + private: + bool _internal_is_cancelled() const; + void _internal_set_is_cancelled(bool value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 7, 1, + 34, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::Any* result_; + ::int32_t session_id_; + ::int32_t request_id_; + ::uint64_t client_id_; + bool is_last_; + bool is_cancelled_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcRequest) */ { + public: + inline RpcRequest() : RpcRequest(nullptr) {} + ~RpcRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcRequest(const RpcRequest& from) : RpcRequest(nullptr, from) {} + inline RpcRequest(RpcRequest&& from) noexcept + : RpcRequest(nullptr, std::move(from)) {} + inline RpcRequest& operator=(const RpcRequest& from) { + CopyFrom(from); + return *this; + } + inline RpcRequest& operator=(RpcRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RpcRequest* internal_default_instance() { + return reinterpret_cast( + &_RpcRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 41; + friend void swap(RpcRequest& a, RpcRequest& b) { a.Swap(&b); } + inline void Swap(RpcRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcRequest& from) { RpcRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcRequest"; } + + protected: + explicit RpcRequest(::google::protobuf::Arena* arena); + RpcRequest(::google::protobuf::Arena* arena, const RpcRequest& from); + RpcRequest(::google::protobuf::Arena* arena, RpcRequest&& from) noexcept + : RpcRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kArgumentFieldNumber = 2, + kMethodFieldNumber = 1, + kSessionIdFieldNumber = 3, + kClientIdFieldNumber = 5, + kRequestIdFieldNumber = 4, + }; + // .google.protobuf.Any argument = 2; + bool has_argument() const; + void clear_argument() ; + const ::google::protobuf::Any& argument() const; + PROTOBUF_NODISCARD ::google::protobuf::Any* release_argument(); + ::google::protobuf::Any* mutable_argument(); + void set_allocated_argument(::google::protobuf::Any* value); + void unsafe_arena_set_allocated_argument(::google::protobuf::Any* value); + ::google::protobuf::Any* unsafe_arena_release_argument(); + + private: + const ::google::protobuf::Any& _internal_argument() const; + ::google::protobuf::Any* _internal_mutable_argument(); + + public: + // int32 method = 1; + void clear_method() ; + ::int32_t method() const; + void set_method(::int32_t value); + + private: + ::int32_t _internal_method() const; + void _internal_set_method(::int32_t value); + + public: + // int32 session_id = 3; + void clear_session_id() ; + ::int32_t session_id() const; + void set_session_id(::int32_t value); + + private: + ::int32_t _internal_session_id() const; + void _internal_set_session_id(::int32_t value); + + public: + // uint64 client_id = 5; + void clear_client_id() ; + ::uint64_t client_id() const; + void set_client_id(::uint64_t value); + + private: + ::uint64_t _internal_client_id() const; + void _internal_set_client_id(::uint64_t value); + + public: + // int32 request_id = 4; + void clear_request_id() ; + ::int32_t request_id() const; + void set_request_id(::int32_t value); + + private: + ::int32_t _internal_request_id() const; + void _internal_set_request_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 5, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::Any* argument_; + ::int32_t method_; + ::int32_t session_id_; + ::uint64_t client_id_; + ::int32_t request_id_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcOpenResponse_Method final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcOpenResponse.Method) */ { + public: + inline RpcOpenResponse_Method() : RpcOpenResponse_Method(nullptr) {} + ~RpcOpenResponse_Method() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcOpenResponse_Method* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcOpenResponse_Method)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcOpenResponse_Method( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcOpenResponse_Method(const RpcOpenResponse_Method& from) : RpcOpenResponse_Method(nullptr, from) {} + inline RpcOpenResponse_Method(RpcOpenResponse_Method&& from) noexcept + : RpcOpenResponse_Method(nullptr, std::move(from)) {} + inline RpcOpenResponse_Method& operator=(const RpcOpenResponse_Method& from) { + CopyFrom(from); + return *this; + } + inline RpcOpenResponse_Method& operator=(RpcOpenResponse_Method&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcOpenResponse_Method& default_instance() { + return *internal_default_instance(); + } + static inline const RpcOpenResponse_Method* internal_default_instance() { + return reinterpret_cast( + &_RpcOpenResponse_Method_default_instance_); + } + static constexpr int kIndexInFileMessages = 35; + friend void swap(RpcOpenResponse_Method& a, RpcOpenResponse_Method& b) { a.Swap(&b); } + inline void Swap(RpcOpenResponse_Method* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcOpenResponse_Method* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcOpenResponse_Method* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcOpenResponse_Method& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcOpenResponse_Method& from) { RpcOpenResponse_Method::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcOpenResponse_Method* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcOpenResponse.Method"; } + + protected: + explicit RpcOpenResponse_Method(::google::protobuf::Arena* arena); + RpcOpenResponse_Method(::google::protobuf::Arena* arena, const RpcOpenResponse_Method& from); + RpcOpenResponse_Method(::google::protobuf::Arena* arena, RpcOpenResponse_Method&& from) noexcept + : RpcOpenResponse_Method(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kNameFieldNumber = 1, + kCancelChannelFieldNumber = 5, + kRequestChannelFieldNumber = 3, + kResponseChannelFieldNumber = 4, + kIdFieldNumber = 2, + }; + // string name = 1; + void clear_name() ; + const std::string& name() const; + template + void set_name(Arg_&& arg, Args_... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* value); + + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( + const std::string& value); + std::string* _internal_mutable_name(); + + public: + // string cancel_channel = 5; + void clear_cancel_channel() ; + const std::string& cancel_channel() const; + template + void set_cancel_channel(Arg_&& arg, Args_... args); + std::string* mutable_cancel_channel(); + PROTOBUF_NODISCARD std::string* release_cancel_channel(); + void set_allocated_cancel_channel(std::string* value); + + private: + const std::string& _internal_cancel_channel() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cancel_channel( + const std::string& value); + std::string* _internal_mutable_cancel_channel(); + + public: + // .subspace.RpcOpenResponse.RequestChannel request_channel = 3; + bool has_request_channel() const; + void clear_request_channel() ; + const ::subspace::RpcOpenResponse_RequestChannel& request_channel() const; + PROTOBUF_NODISCARD ::subspace::RpcOpenResponse_RequestChannel* release_request_channel(); + ::subspace::RpcOpenResponse_RequestChannel* mutable_request_channel(); + void set_allocated_request_channel(::subspace::RpcOpenResponse_RequestChannel* value); + void unsafe_arena_set_allocated_request_channel(::subspace::RpcOpenResponse_RequestChannel* value); + ::subspace::RpcOpenResponse_RequestChannel* unsafe_arena_release_request_channel(); + + private: + const ::subspace::RpcOpenResponse_RequestChannel& _internal_request_channel() const; + ::subspace::RpcOpenResponse_RequestChannel* _internal_mutable_request_channel(); + + public: + // .subspace.RpcOpenResponse.ResponseChannel response_channel = 4; + bool has_response_channel() const; + void clear_response_channel() ; + const ::subspace::RpcOpenResponse_ResponseChannel& response_channel() const; + PROTOBUF_NODISCARD ::subspace::RpcOpenResponse_ResponseChannel* release_response_channel(); + ::subspace::RpcOpenResponse_ResponseChannel* mutable_response_channel(); + void set_allocated_response_channel(::subspace::RpcOpenResponse_ResponseChannel* value); + void unsafe_arena_set_allocated_response_channel(::subspace::RpcOpenResponse_ResponseChannel* value); + ::subspace::RpcOpenResponse_ResponseChannel* unsafe_arena_release_response_channel(); + + private: + const ::subspace::RpcOpenResponse_ResponseChannel& _internal_response_channel() const; + ::subspace::RpcOpenResponse_ResponseChannel* _internal_mutable_response_channel(); + + public: + // int32 id = 2; + void clear_id() ; + ::int32_t id() const; + void set_id(::int32_t value); + + private: + ::int32_t _internal_id() const; + void _internal_set_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcOpenResponse.Method) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 5, 2, + 58, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcOpenResponse_Method& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr name_; + ::google::protobuf::internal::ArenaStringPtr cancel_channel_; + ::subspace::RpcOpenResponse_RequestChannel* request_channel_; + ::subspace::RpcOpenResponse_ResponseChannel* response_channel_; + ::int32_t id_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class GetChannelStatsResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.GetChannelStatsResponse) */ { + public: + inline GetChannelStatsResponse() : GetChannelStatsResponse(nullptr) {} + ~GetChannelStatsResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetChannelStatsResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetChannelStatsResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetChannelStatsResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline GetChannelStatsResponse(const GetChannelStatsResponse& from) : GetChannelStatsResponse(nullptr, from) {} + inline GetChannelStatsResponse(GetChannelStatsResponse&& from) noexcept + : GetChannelStatsResponse(nullptr, std::move(from)) {} + inline GetChannelStatsResponse& operator=(const GetChannelStatsResponse& from) { + CopyFrom(from); + return *this; + } + inline GetChannelStatsResponse& operator=(GetChannelStatsResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GetChannelStatsResponse& default_instance() { + return *internal_default_instance(); + } + static inline const GetChannelStatsResponse* internal_default_instance() { + return reinterpret_cast( + &_GetChannelStatsResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 15; + friend void swap(GetChannelStatsResponse& a, GetChannelStatsResponse& b) { a.Swap(&b); } + inline void Swap(GetChannelStatsResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetChannelStatsResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetChannelStatsResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GetChannelStatsResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GetChannelStatsResponse& from) { GetChannelStatsResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetChannelStatsResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.GetChannelStatsResponse"; } + + protected: + explicit GetChannelStatsResponse(::google::protobuf::Arena* arena); + GetChannelStatsResponse(::google::protobuf::Arena* arena, const GetChannelStatsResponse& from); + GetChannelStatsResponse(::google::protobuf::Arena* arena, GetChannelStatsResponse&& from) noexcept + : GetChannelStatsResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelsFieldNumber = 2, + kErrorFieldNumber = 1, + }; + // repeated .subspace.ChannelStatsProto channels = 2; + int channels_size() const; + private: + int _internal_channels_size() const; + + public: + void clear_channels() ; + ::subspace::ChannelStatsProto* mutable_channels(int index); + ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* mutable_channels(); + + private: + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& _internal_channels() const; + ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* _internal_mutable_channels(); + public: + const ::subspace::ChannelStatsProto& channels(int index) const; + ::subspace::ChannelStatsProto* add_channels(); + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& channels() const; + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // @@protoc_insertion_point(class_scope:subspace.GetChannelStatsResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 1, + 46, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetChannelStatsResponse& from_msg); + ::google::protobuf::RepeatedPtrField< ::subspace::ChannelStatsProto > channels_; + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class GetChannelInfoResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.GetChannelInfoResponse) */ { + public: + inline GetChannelInfoResponse() : GetChannelInfoResponse(nullptr) {} + ~GetChannelInfoResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetChannelInfoResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetChannelInfoResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetChannelInfoResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline GetChannelInfoResponse(const GetChannelInfoResponse& from) : GetChannelInfoResponse(nullptr, from) {} + inline GetChannelInfoResponse(GetChannelInfoResponse&& from) noexcept + : GetChannelInfoResponse(nullptr, std::move(from)) {} + inline GetChannelInfoResponse& operator=(const GetChannelInfoResponse& from) { + CopyFrom(from); + return *this; + } + inline GetChannelInfoResponse& operator=(GetChannelInfoResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GetChannelInfoResponse& default_instance() { + return *internal_default_instance(); + } + static inline const GetChannelInfoResponse* internal_default_instance() { + return reinterpret_cast( + &_GetChannelInfoResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 13; + friend void swap(GetChannelInfoResponse& a, GetChannelInfoResponse& b) { a.Swap(&b); } + inline void Swap(GetChannelInfoResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetChannelInfoResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetChannelInfoResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GetChannelInfoResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GetChannelInfoResponse& from) { GetChannelInfoResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetChannelInfoResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.GetChannelInfoResponse"; } + + protected: + explicit GetChannelInfoResponse(::google::protobuf::Arena* arena); + GetChannelInfoResponse(::google::protobuf::Arena* arena, const GetChannelInfoResponse& from); + GetChannelInfoResponse(::google::protobuf::Arena* arena, GetChannelInfoResponse&& from) noexcept + : GetChannelInfoResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelsFieldNumber = 2, + kErrorFieldNumber = 1, + }; + // repeated .subspace.ChannelInfoProto channels = 2; + int channels_size() const; + private: + int _internal_channels_size() const; + + public: + void clear_channels() ; + ::subspace::ChannelInfoProto* mutable_channels(int index); + ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* mutable_channels(); + + private: + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& _internal_channels() const; + ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* _internal_mutable_channels(); + public: + const ::subspace::ChannelInfoProto& channels(int index) const; + ::subspace::ChannelInfoProto* add_channels(); + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& channels() const; + // string error = 1; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // @@protoc_insertion_point(class_scope:subspace.GetChannelInfoResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 1, + 45, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetChannelInfoResponse& from_msg); + ::google::protobuf::RepeatedPtrField< ::subspace::ChannelInfoProto > channels_; + ::google::protobuf::internal::ArenaStringPtr error_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Discovery_Subscribe final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Discovery.Subscribe) */ { + public: + inline Discovery_Subscribe() : Discovery_Subscribe(nullptr) {} + ~Discovery_Subscribe() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Discovery_Subscribe* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Discovery_Subscribe)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Discovery_Subscribe( + ::google::protobuf::internal::ConstantInitialized); + + inline Discovery_Subscribe(const Discovery_Subscribe& from) : Discovery_Subscribe(nullptr, from) {} + inline Discovery_Subscribe(Discovery_Subscribe&& from) noexcept + : Discovery_Subscribe(nullptr, std::move(from)) {} + inline Discovery_Subscribe& operator=(const Discovery_Subscribe& from) { + CopyFrom(from); + return *this; + } + inline Discovery_Subscribe& operator=(Discovery_Subscribe&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Discovery_Subscribe& default_instance() { + return *internal_default_instance(); + } + static inline const Discovery_Subscribe* internal_default_instance() { + return reinterpret_cast( + &_Discovery_Subscribe_default_instance_); + } + static constexpr int kIndexInFileMessages = 30; + friend void swap(Discovery_Subscribe& a, Discovery_Subscribe& b) { a.Swap(&b); } + inline void Swap(Discovery_Subscribe* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Discovery_Subscribe* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Discovery_Subscribe* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Discovery_Subscribe& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Discovery_Subscribe& from) { Discovery_Subscribe::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Discovery_Subscribe* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Discovery.Subscribe"; } + + protected: + explicit Discovery_Subscribe(::google::protobuf::Arena* arena); + Discovery_Subscribe(::google::protobuf::Arena* arena, const Discovery_Subscribe& from); + Discovery_Subscribe(::google::protobuf::Arena* arena, Discovery_Subscribe&& from) noexcept + : Discovery_Subscribe(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kReceiverFieldNumber = 2, + kReliableFieldNumber = 3, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // .subspace.ChannelAddress receiver = 2; + bool has_receiver() const; + void clear_receiver() ; + const ::subspace::ChannelAddress& receiver() const; + PROTOBUF_NODISCARD ::subspace::ChannelAddress* release_receiver(); + ::subspace::ChannelAddress* mutable_receiver(); + void set_allocated_receiver(::subspace::ChannelAddress* value); + void unsafe_arena_set_allocated_receiver(::subspace::ChannelAddress* value); + ::subspace::ChannelAddress* unsafe_arena_release_receiver(); + + private: + const ::subspace::ChannelAddress& _internal_receiver() const; + ::subspace::ChannelAddress* _internal_mutable_receiver(); + + public: + // bool reliable = 3; + void clear_reliable() ; + bool reliable() const; + void set_reliable(bool value); + + private: + bool _internal_reliable() const; + void _internal_set_reliable(bool value); + + public: + // @@protoc_insertion_point(class_scope:subspace.Discovery.Subscribe) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 1, + 49, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Discovery_Subscribe& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::subspace::ChannelAddress* receiver_; + bool reliable_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientBufferHandleMetadataProto final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ClientBufferHandleMetadataProto) */ { + public: + inline ClientBufferHandleMetadataProto() : ClientBufferHandleMetadataProto(nullptr) {} + ~ClientBufferHandleMetadataProto() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClientBufferHandleMetadataProto* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClientBufferHandleMetadataProto)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClientBufferHandleMetadataProto( + ::google::protobuf::internal::ConstantInitialized); + + inline ClientBufferHandleMetadataProto(const ClientBufferHandleMetadataProto& from) : ClientBufferHandleMetadataProto(nullptr, from) {} + inline ClientBufferHandleMetadataProto(ClientBufferHandleMetadataProto&& from) noexcept + : ClientBufferHandleMetadataProto(nullptr, std::move(from)) {} + inline ClientBufferHandleMetadataProto& operator=(const ClientBufferHandleMetadataProto& from) { + CopyFrom(from); + return *this; + } + inline ClientBufferHandleMetadataProto& operator=(ClientBufferHandleMetadataProto&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientBufferHandleMetadataProto& default_instance() { + return *internal_default_instance(); + } + static inline const ClientBufferHandleMetadataProto* internal_default_instance() { + return reinterpret_cast( + &_ClientBufferHandleMetadataProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 16; + friend void swap(ClientBufferHandleMetadataProto& a, ClientBufferHandleMetadataProto& b) { a.Swap(&b); } + inline void Swap(ClientBufferHandleMetadataProto* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientBufferHandleMetadataProto* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientBufferHandleMetadataProto* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ClientBufferHandleMetadataProto& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ClientBufferHandleMetadataProto& from) { ClientBufferHandleMetadataProto::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClientBufferHandleMetadataProto* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ClientBufferHandleMetadataProto"; } + + protected: + explicit ClientBufferHandleMetadataProto(::google::protobuf::Arena* arena); + ClientBufferHandleMetadataProto(::google::protobuf::Arena* arena, const ClientBufferHandleMetadataProto& from); + ClientBufferHandleMetadataProto(::google::protobuf::Arena* arena, ClientBufferHandleMetadataProto&& from) noexcept + : ClientBufferHandleMetadataProto(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelNameFieldNumber = 1, + kShadowFileFieldNumber = 9, + kObjectNameFieldNumber = 10, + kAllocatorFieldNumber = 11, + kPoolIdFieldNumber = 12, + kAllocatorMetadataFieldNumber = 15, + kSessionIdFieldNumber = 2, + kBufferIndexFieldNumber = 3, + kSlotIdFieldNumber = 4, + kFullSizeFieldNumber = 6, + kAllocationSizeFieldNumber = 7, + kHandleFieldNumber = 8, + kIsPrefixFieldNumber = 5, + kCacheEnabledFieldNumber = 13, + kAlignmentFieldNumber = 14, + }; + // string channel_name = 1; + void clear_channel_name() ; + const std::string& channel_name() const; + template + void set_channel_name(Arg_&& arg, Args_... args); + std::string* mutable_channel_name(); + PROTOBUF_NODISCARD std::string* release_channel_name(); + void set_allocated_channel_name(std::string* value); + + private: + const std::string& _internal_channel_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel_name( + const std::string& value); + std::string* _internal_mutable_channel_name(); + + public: + // string shadow_file = 9; + void clear_shadow_file() ; + const std::string& shadow_file() const; + template + void set_shadow_file(Arg_&& arg, Args_... args); + std::string* mutable_shadow_file(); + PROTOBUF_NODISCARD std::string* release_shadow_file(); + void set_allocated_shadow_file(std::string* value); + + private: + const std::string& _internal_shadow_file() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_shadow_file( + const std::string& value); + std::string* _internal_mutable_shadow_file(); + + public: + // string object_name = 10; + void clear_object_name() ; + const std::string& object_name() const; + template + void set_object_name(Arg_&& arg, Args_... args); + std::string* mutable_object_name(); + PROTOBUF_NODISCARD std::string* release_object_name(); + void set_allocated_object_name(std::string* value); + + private: + const std::string& _internal_object_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_object_name( + const std::string& value); + std::string* _internal_mutable_object_name(); + + public: + // string allocator = 11; + void clear_allocator() ; + const std::string& allocator() const; + template + void set_allocator(Arg_&& arg, Args_... args); + std::string* mutable_allocator(); + PROTOBUF_NODISCARD std::string* release_allocator(); + void set_allocated_allocator(std::string* value); + + private: + const std::string& _internal_allocator() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator( + const std::string& value); + std::string* _internal_mutable_allocator(); + + public: + // string pool_id = 12; + void clear_pool_id() ; + const std::string& pool_id() const; + template + void set_pool_id(Arg_&& arg, Args_... args); + std::string* mutable_pool_id(); + PROTOBUF_NODISCARD std::string* release_pool_id(); + void set_allocated_pool_id(std::string* value); + + private: + const std::string& _internal_pool_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pool_id( + const std::string& value); + std::string* _internal_mutable_pool_id(); + + public: + // .google.protobuf.Any allocator_metadata = 15; + bool has_allocator_metadata() const; + void clear_allocator_metadata() ; + const ::google::protobuf::Any& allocator_metadata() const; + PROTOBUF_NODISCARD ::google::protobuf::Any* release_allocator_metadata(); + ::google::protobuf::Any* mutable_allocator_metadata(); + void set_allocated_allocator_metadata(::google::protobuf::Any* value); + void unsafe_arena_set_allocated_allocator_metadata(::google::protobuf::Any* value); + ::google::protobuf::Any* unsafe_arena_release_allocator_metadata(); + + private: + const ::google::protobuf::Any& _internal_allocator_metadata() const; + ::google::protobuf::Any* _internal_mutable_allocator_metadata(); + + public: + // uint64 session_id = 2; + void clear_session_id() ; + ::uint64_t session_id() const; + void set_session_id(::uint64_t value); + + private: + ::uint64_t _internal_session_id() const; + void _internal_set_session_id(::uint64_t value); + + public: + // uint32 buffer_index = 3; + void clear_buffer_index() ; + ::uint32_t buffer_index() const; + void set_buffer_index(::uint32_t value); + + private: + ::uint32_t _internal_buffer_index() const; + void _internal_set_buffer_index(::uint32_t value); + + public: + // uint32 slot_id = 4; + void clear_slot_id() ; + ::uint32_t slot_id() const; + void set_slot_id(::uint32_t value); + + private: + ::uint32_t _internal_slot_id() const; + void _internal_set_slot_id(::uint32_t value); + + public: + // uint64 full_size = 6; + void clear_full_size() ; + ::uint64_t full_size() const; + void set_full_size(::uint64_t value); + + private: + ::uint64_t _internal_full_size() const; + void _internal_set_full_size(::uint64_t value); + + public: + // uint64 allocation_size = 7; + void clear_allocation_size() ; + ::uint64_t allocation_size() const; + void set_allocation_size(::uint64_t value); + + private: + ::uint64_t _internal_allocation_size() const; + void _internal_set_allocation_size(::uint64_t value); + + public: + // uint64 handle = 8; + void clear_handle() ; + ::uint64_t handle() const; + void set_handle(::uint64_t value); + + private: + ::uint64_t _internal_handle() const; + void _internal_set_handle(::uint64_t value); + + public: + // bool is_prefix = 5; + void clear_is_prefix() ; + bool is_prefix() const; + void set_is_prefix(bool value); + + private: + bool _internal_is_prefix() const; + void _internal_set_is_prefix(bool value); + + public: + // bool cache_enabled = 13; + void clear_cache_enabled() ; + bool cache_enabled() const; + void set_cache_enabled(bool value); + + private: + bool _internal_cache_enabled() const; + void _internal_set_cache_enabled(bool value); + + public: + // uint32 alignment = 14; + void clear_alignment() ; + ::uint32_t alignment() const; + void set_alignment(::uint32_t value); + + private: + ::uint32_t _internal_alignment() const; + void _internal_set_alignment(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.ClientBufferHandleMetadataProto) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 15, 1, + 107, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ClientBufferHandleMetadataProto& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr channel_name_; + ::google::protobuf::internal::ArenaStringPtr shadow_file_; + ::google::protobuf::internal::ArenaStringPtr object_name_; + ::google::protobuf::internal::ArenaStringPtr allocator_; + ::google::protobuf::internal::ArenaStringPtr pool_id_; + ::google::protobuf::Any* allocator_metadata_; + ::uint64_t session_id_; + ::uint32_t buffer_index_; + ::uint32_t slot_id_; + ::uint64_t full_size_; + ::uint64_t allocation_size_; + ::uint64_t handle_; + bool is_prefix_; + bool cache_enabled_; + ::uint32_t alignment_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ChannelDirectory final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ChannelDirectory) */ { + public: + inline ChannelDirectory() : ChannelDirectory(nullptr) {} + ~ChannelDirectory() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ChannelDirectory* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ChannelDirectory)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ChannelDirectory( + ::google::protobuf::internal::ConstantInitialized); + + inline ChannelDirectory(const ChannelDirectory& from) : ChannelDirectory(nullptr, from) {} + inline ChannelDirectory(ChannelDirectory&& from) noexcept + : ChannelDirectory(nullptr, std::move(from)) {} + inline ChannelDirectory& operator=(const ChannelDirectory& from) { + CopyFrom(from); + return *this; + } + inline ChannelDirectory& operator=(ChannelDirectory&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ChannelDirectory& default_instance() { + return *internal_default_instance(); + } + static inline const ChannelDirectory* internal_default_instance() { + return reinterpret_cast( + &_ChannelDirectory_default_instance_); + } + static constexpr int kIndexInFileMessages = 22; + friend void swap(ChannelDirectory& a, ChannelDirectory& b) { a.Swap(&b); } + inline void Swap(ChannelDirectory* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChannelDirectory* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChannelDirectory* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ChannelDirectory& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ChannelDirectory& from) { ChannelDirectory::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ChannelDirectory* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ChannelDirectory"; } + + protected: + explicit ChannelDirectory(::google::protobuf::Arena* arena); + ChannelDirectory(::google::protobuf::Arena* arena, const ChannelDirectory& from); + ChannelDirectory(::google::protobuf::Arena* arena, ChannelDirectory&& from) noexcept + : ChannelDirectory(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kChannelsFieldNumber = 2, + kServerIdFieldNumber = 1, + }; + // repeated .subspace.ChannelInfoProto channels = 2; + int channels_size() const; + private: + int _internal_channels_size() const; + + public: + void clear_channels() ; + ::subspace::ChannelInfoProto* mutable_channels(int index); + ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* mutable_channels(); + + private: + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& _internal_channels() const; + ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* _internal_mutable_channels(); + public: + const ::subspace::ChannelInfoProto& channels(int index) const; + ::subspace::ChannelInfoProto* add_channels(); + const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& channels() const; + // string server_id = 1; + void clear_server_id() ; + const std::string& server_id() const; + template + void set_server_id(Arg_&& arg, Args_... args); + std::string* mutable_server_id(); + PROTOBUF_NODISCARD std::string* release_server_id(); + void set_allocated_server_id(std::string* value); + + private: + const std::string& _internal_server_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id( + const std::string& value); + std::string* _internal_mutable_server_id(); + + public: + // @@protoc_insertion_point(class_scope:subspace.ChannelDirectory) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 1, + 43, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ChannelDirectory& from_msg); + ::google::protobuf::RepeatedPtrField< ::subspace::ChannelInfoProto > channels_; + ::google::protobuf::internal::ArenaStringPtr server_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowRegisterClientBuffer final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowRegisterClientBuffer) */ { + public: + inline ShadowRegisterClientBuffer() : ShadowRegisterClientBuffer(nullptr) {} + ~ShadowRegisterClientBuffer() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowRegisterClientBuffer* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowRegisterClientBuffer)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowRegisterClientBuffer( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowRegisterClientBuffer(const ShadowRegisterClientBuffer& from) : ShadowRegisterClientBuffer(nullptr, from) {} + inline ShadowRegisterClientBuffer(ShadowRegisterClientBuffer&& from) noexcept + : ShadowRegisterClientBuffer(nullptr, std::move(from)) {} + inline ShadowRegisterClientBuffer& operator=(const ShadowRegisterClientBuffer& from) { + CopyFrom(from); + return *this; + } + inline ShadowRegisterClientBuffer& operator=(ShadowRegisterClientBuffer&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowRegisterClientBuffer& default_instance() { + return *internal_default_instance(); + } + static inline const ShadowRegisterClientBuffer* internal_default_instance() { + return reinterpret_cast( + &_ShadowRegisterClientBuffer_default_instance_); + } + static constexpr int kIndexInFileMessages = 56; + friend void swap(ShadowRegisterClientBuffer& a, ShadowRegisterClientBuffer& b) { a.Swap(&b); } + inline void Swap(ShadowRegisterClientBuffer* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowRegisterClientBuffer* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowRegisterClientBuffer* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowRegisterClientBuffer& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowRegisterClientBuffer& from) { ShadowRegisterClientBuffer::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowRegisterClientBuffer* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowRegisterClientBuffer"; } + + protected: + explicit ShadowRegisterClientBuffer(::google::protobuf::Arena* arena); + ShadowRegisterClientBuffer(::google::protobuf::Arena* arena, const ShadowRegisterClientBuffer& from); + ShadowRegisterClientBuffer(::google::protobuf::Arena* arena, ShadowRegisterClientBuffer&& from) noexcept + : ShadowRegisterClientBuffer(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kMetadataFieldNumber = 1, + }; + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + bool has_metadata() const; + void clear_metadata() ; + const ::subspace::ClientBufferHandleMetadataProto& metadata() const; + PROTOBUF_NODISCARD ::subspace::ClientBufferHandleMetadataProto* release_metadata(); + ::subspace::ClientBufferHandleMetadataProto* mutable_metadata(); + void set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value); + void unsafe_arena_set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value); + ::subspace::ClientBufferHandleMetadataProto* unsafe_arena_release_metadata(); + + private: + const ::subspace::ClientBufferHandleMetadataProto& _internal_metadata() const; + ::subspace::ClientBufferHandleMetadataProto* _internal_mutable_metadata(); + + public: + // @@protoc_insertion_point(class_scope:subspace.ShadowRegisterClientBuffer) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowRegisterClientBuffer& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::subspace::ClientBufferHandleMetadataProto* metadata_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcOpenResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcOpenResponse) */ { + public: + inline RpcOpenResponse() : RpcOpenResponse(nullptr) {} + ~RpcOpenResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcOpenResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcOpenResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcOpenResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcOpenResponse(const RpcOpenResponse& from) : RpcOpenResponse(nullptr, from) {} + inline RpcOpenResponse(RpcOpenResponse&& from) noexcept + : RpcOpenResponse(nullptr, std::move(from)) {} + inline RpcOpenResponse& operator=(const RpcOpenResponse& from) { + CopyFrom(from); + return *this; + } + inline RpcOpenResponse& operator=(RpcOpenResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcOpenResponse& default_instance() { + return *internal_default_instance(); + } + static inline const RpcOpenResponse* internal_default_instance() { + return reinterpret_cast( + &_RpcOpenResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 36; + friend void swap(RpcOpenResponse& a, RpcOpenResponse& b) { a.Swap(&b); } + inline void Swap(RpcOpenResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcOpenResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcOpenResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcOpenResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcOpenResponse& from) { RpcOpenResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcOpenResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcOpenResponse"; } + + protected: + explicit RpcOpenResponse(::google::protobuf::Arena* arena); + RpcOpenResponse(::google::protobuf::Arena* arena, const RpcOpenResponse& from); + RpcOpenResponse(::google::protobuf::Arena* arena, RpcOpenResponse&& from) noexcept + : RpcOpenResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using RequestChannel = RpcOpenResponse_RequestChannel; + using ResponseChannel = RpcOpenResponse_ResponseChannel; + using Method = RpcOpenResponse_Method; + + // accessors ------------------------------------------------------- + enum : int { + kMethodsFieldNumber = 2, + kClientIdFieldNumber = 3, + kSessionIdFieldNumber = 1, + }; + // repeated .subspace.RpcOpenResponse.Method methods = 2; + int methods_size() const; + private: + int _internal_methods_size() const; + + public: + void clear_methods() ; + ::subspace::RpcOpenResponse_Method* mutable_methods(int index); + ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>* mutable_methods(); + + private: + const ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>& _internal_methods() const; + ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>* _internal_mutable_methods(); + public: + const ::subspace::RpcOpenResponse_Method& methods(int index) const; + ::subspace::RpcOpenResponse_Method* add_methods(); + const ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>& methods() const; + // uint64 client_id = 3; + void clear_client_id() ; + ::uint64_t client_id() const; + void set_client_id(::uint64_t value); + + private: + ::uint64_t _internal_client_id() const; + void _internal_set_client_id(::uint64_t value); + + public: + // int32 session_id = 1; + void clear_session_id() ; + ::int32_t session_id() const; + void set_session_id(::int32_t value); + + private: + ::int32_t _internal_session_id() const; + void _internal_set_session_id(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:subspace.RpcOpenResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcOpenResponse& from_msg); + ::google::protobuf::RepeatedPtrField< ::subspace::RpcOpenResponse_Method > methods_; + ::uint64_t client_id_; + ::int32_t session_id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Response final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Response) */ { + public: + inline Response() : Response(nullptr) {} + ~Response() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Response* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Response)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Response( + ::google::protobuf::internal::ConstantInitialized); + + inline Response(const Response& from) : Response(nullptr, from) {} + inline Response(Response&& from) noexcept + : Response(nullptr, std::move(from)) {} + inline Response& operator=(const Response& from) { + CopyFrom(from); + return *this; + } + inline Response& operator=(Response&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Response& default_instance() { + return *internal_default_instance(); + } + enum ResponseCase { + kInit = 1, + kCreatePublisher = 2, + kCreateSubscriber = 3, + kGetTriggers = 4, + kRemovePublisher = 5, + kRemoveSubscriber = 6, + kGetChannelInfo = 9, + kGetChannelStats = 10, + RESPONSE_NOT_SET = 0, + }; + static inline const Response* internal_default_instance() { + return reinterpret_cast( + &_Response_default_instance_); + } + static constexpr int kIndexInFileMessages = 20; + friend void swap(Response& a, Response& b) { a.Swap(&b); } + inline void Swap(Response* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Response* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Response* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Response& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Response& from) { Response::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Response* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Response"; } + + protected: + explicit Response(::google::protobuf::Arena* arena); + Response(::google::protobuf::Arena* arena, const Response& from); + Response(::google::protobuf::Arena* arena, Response&& from) noexcept + : Response(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kInitFieldNumber = 1, + kCreatePublisherFieldNumber = 2, + kCreateSubscriberFieldNumber = 3, + kGetTriggersFieldNumber = 4, + kRemovePublisherFieldNumber = 5, + kRemoveSubscriberFieldNumber = 6, + kGetChannelInfoFieldNumber = 9, + kGetChannelStatsFieldNumber = 10, + }; + // .subspace.InitResponse init = 1; + bool has_init() const; + private: + bool _internal_has_init() const; + + public: + void clear_init() ; + const ::subspace::InitResponse& init() const; + PROTOBUF_NODISCARD ::subspace::InitResponse* release_init(); + ::subspace::InitResponse* mutable_init(); + void set_allocated_init(::subspace::InitResponse* value); + void unsafe_arena_set_allocated_init(::subspace::InitResponse* value); + ::subspace::InitResponse* unsafe_arena_release_init(); + + private: + const ::subspace::InitResponse& _internal_init() const; + ::subspace::InitResponse* _internal_mutable_init(); + + public: + // .subspace.CreatePublisherResponse create_publisher = 2; + bool has_create_publisher() const; + private: + bool _internal_has_create_publisher() const; + + public: + void clear_create_publisher() ; + const ::subspace::CreatePublisherResponse& create_publisher() const; + PROTOBUF_NODISCARD ::subspace::CreatePublisherResponse* release_create_publisher(); + ::subspace::CreatePublisherResponse* mutable_create_publisher(); + void set_allocated_create_publisher(::subspace::CreatePublisherResponse* value); + void unsafe_arena_set_allocated_create_publisher(::subspace::CreatePublisherResponse* value); + ::subspace::CreatePublisherResponse* unsafe_arena_release_create_publisher(); + + private: + const ::subspace::CreatePublisherResponse& _internal_create_publisher() const; + ::subspace::CreatePublisherResponse* _internal_mutable_create_publisher(); + + public: + // .subspace.CreateSubscriberResponse create_subscriber = 3; + bool has_create_subscriber() const; + private: + bool _internal_has_create_subscriber() const; + + public: + void clear_create_subscriber() ; + const ::subspace::CreateSubscriberResponse& create_subscriber() const; + PROTOBUF_NODISCARD ::subspace::CreateSubscriberResponse* release_create_subscriber(); + ::subspace::CreateSubscriberResponse* mutable_create_subscriber(); + void set_allocated_create_subscriber(::subspace::CreateSubscriberResponse* value); + void unsafe_arena_set_allocated_create_subscriber(::subspace::CreateSubscriberResponse* value); + ::subspace::CreateSubscriberResponse* unsafe_arena_release_create_subscriber(); + + private: + const ::subspace::CreateSubscriberResponse& _internal_create_subscriber() const; + ::subspace::CreateSubscriberResponse* _internal_mutable_create_subscriber(); + + public: + // .subspace.GetTriggersResponse get_triggers = 4; + bool has_get_triggers() const; + private: + bool _internal_has_get_triggers() const; + + public: + void clear_get_triggers() ; + const ::subspace::GetTriggersResponse& get_triggers() const; + PROTOBUF_NODISCARD ::subspace::GetTriggersResponse* release_get_triggers(); + ::subspace::GetTriggersResponse* mutable_get_triggers(); + void set_allocated_get_triggers(::subspace::GetTriggersResponse* value); + void unsafe_arena_set_allocated_get_triggers(::subspace::GetTriggersResponse* value); + ::subspace::GetTriggersResponse* unsafe_arena_release_get_triggers(); + + private: + const ::subspace::GetTriggersResponse& _internal_get_triggers() const; + ::subspace::GetTriggersResponse* _internal_mutable_get_triggers(); + + public: + // .subspace.RemovePublisherResponse remove_publisher = 5; + bool has_remove_publisher() const; + private: + bool _internal_has_remove_publisher() const; + + public: + void clear_remove_publisher() ; + const ::subspace::RemovePublisherResponse& remove_publisher() const; + PROTOBUF_NODISCARD ::subspace::RemovePublisherResponse* release_remove_publisher(); + ::subspace::RemovePublisherResponse* mutable_remove_publisher(); + void set_allocated_remove_publisher(::subspace::RemovePublisherResponse* value); + void unsafe_arena_set_allocated_remove_publisher(::subspace::RemovePublisherResponse* value); + ::subspace::RemovePublisherResponse* unsafe_arena_release_remove_publisher(); + + private: + const ::subspace::RemovePublisherResponse& _internal_remove_publisher() const; + ::subspace::RemovePublisherResponse* _internal_mutable_remove_publisher(); + + public: + // .subspace.RemoveSubscriberResponse remove_subscriber = 6; + bool has_remove_subscriber() const; + private: + bool _internal_has_remove_subscriber() const; + + public: + void clear_remove_subscriber() ; + const ::subspace::RemoveSubscriberResponse& remove_subscriber() const; + PROTOBUF_NODISCARD ::subspace::RemoveSubscriberResponse* release_remove_subscriber(); + ::subspace::RemoveSubscriberResponse* mutable_remove_subscriber(); + void set_allocated_remove_subscriber(::subspace::RemoveSubscriberResponse* value); + void unsafe_arena_set_allocated_remove_subscriber(::subspace::RemoveSubscriberResponse* value); + ::subspace::RemoveSubscriberResponse* unsafe_arena_release_remove_subscriber(); + + private: + const ::subspace::RemoveSubscriberResponse& _internal_remove_subscriber() const; + ::subspace::RemoveSubscriberResponse* _internal_mutable_remove_subscriber(); + + public: + // .subspace.GetChannelInfoResponse get_channel_info = 9; + bool has_get_channel_info() const; + private: + bool _internal_has_get_channel_info() const; + + public: + void clear_get_channel_info() ; + const ::subspace::GetChannelInfoResponse& get_channel_info() const; + PROTOBUF_NODISCARD ::subspace::GetChannelInfoResponse* release_get_channel_info(); + ::subspace::GetChannelInfoResponse* mutable_get_channel_info(); + void set_allocated_get_channel_info(::subspace::GetChannelInfoResponse* value); + void unsafe_arena_set_allocated_get_channel_info(::subspace::GetChannelInfoResponse* value); + ::subspace::GetChannelInfoResponse* unsafe_arena_release_get_channel_info(); + + private: + const ::subspace::GetChannelInfoResponse& _internal_get_channel_info() const; + ::subspace::GetChannelInfoResponse* _internal_mutable_get_channel_info(); + + public: + // .subspace.GetChannelStatsResponse get_channel_stats = 10; + bool has_get_channel_stats() const; + private: + bool _internal_has_get_channel_stats() const; + + public: + void clear_get_channel_stats() ; + const ::subspace::GetChannelStatsResponse& get_channel_stats() const; + PROTOBUF_NODISCARD ::subspace::GetChannelStatsResponse* release_get_channel_stats(); + ::subspace::GetChannelStatsResponse* mutable_get_channel_stats(); + void set_allocated_get_channel_stats(::subspace::GetChannelStatsResponse* value); + void unsafe_arena_set_allocated_get_channel_stats(::subspace::GetChannelStatsResponse* value); + ::subspace::GetChannelStatsResponse* unsafe_arena_release_get_channel_stats(); + + private: + const ::subspace::GetChannelStatsResponse& _internal_get_channel_stats() const; + ::subspace::GetChannelStatsResponse* _internal_mutable_get_channel_stats(); + + public: + void clear_response(); + ResponseCase response_case() const; + // @@protoc_insertion_point(class_scope:subspace.Response) + private: + class _Internal; + void set_has_init(); + void set_has_create_publisher(); + void set_has_create_subscriber(); + void set_has_get_triggers(); + void set_has_remove_publisher(); + void set_has_remove_subscriber(); + void set_has_get_channel_info(); + void set_has_get_channel_stats(); + inline bool has_response() const; + inline void clear_has_response(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 8, 8, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Response& from_msg); + union ResponseUnion { + constexpr ResponseUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::subspace::InitResponse* init_; + ::subspace::CreatePublisherResponse* create_publisher_; + ::subspace::CreateSubscriberResponse* create_subscriber_; + ::subspace::GetTriggersResponse* get_triggers_; + ::subspace::RemovePublisherResponse* remove_publisher_; + ::subspace::RemoveSubscriberResponse* remove_subscriber_; + ::subspace::GetChannelInfoResponse* get_channel_info_; + ::subspace::GetChannelStatsResponse* get_channel_stats_; + } response_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RegisterClientBufferRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RegisterClientBufferRequest) */ { + public: + inline RegisterClientBufferRequest() : RegisterClientBufferRequest(nullptr) {} + ~RegisterClientBufferRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RegisterClientBufferRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RegisterClientBufferRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RegisterClientBufferRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RegisterClientBufferRequest(const RegisterClientBufferRequest& from) : RegisterClientBufferRequest(nullptr, from) {} + inline RegisterClientBufferRequest(RegisterClientBufferRequest&& from) noexcept + : RegisterClientBufferRequest(nullptr, std::move(from)) {} + inline RegisterClientBufferRequest& operator=(const RegisterClientBufferRequest& from) { + CopyFrom(from); + return *this; + } + inline RegisterClientBufferRequest& operator=(RegisterClientBufferRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RegisterClientBufferRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RegisterClientBufferRequest* internal_default_instance() { + return reinterpret_cast( + &_RegisterClientBufferRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 17; + friend void swap(RegisterClientBufferRequest& a, RegisterClientBufferRequest& b) { a.Swap(&b); } + inline void Swap(RegisterClientBufferRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RegisterClientBufferRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RegisterClientBufferRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RegisterClientBufferRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RegisterClientBufferRequest& from) { RegisterClientBufferRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RegisterClientBufferRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RegisterClientBufferRequest"; } + + protected: + explicit RegisterClientBufferRequest(::google::protobuf::Arena* arena); + RegisterClientBufferRequest(::google::protobuf::Arena* arena, const RegisterClientBufferRequest& from); + RegisterClientBufferRequest(::google::protobuf::Arena* arena, RegisterClientBufferRequest&& from) noexcept + : RegisterClientBufferRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kMetadataFieldNumber = 1, + }; + // .subspace.ClientBufferHandleMetadataProto metadata = 1; + bool has_metadata() const; + void clear_metadata() ; + const ::subspace::ClientBufferHandleMetadataProto& metadata() const; + PROTOBUF_NODISCARD ::subspace::ClientBufferHandleMetadataProto* release_metadata(); + ::subspace::ClientBufferHandleMetadataProto* mutable_metadata(); + void set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value); + void unsafe_arena_set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value); + ::subspace::ClientBufferHandleMetadataProto* unsafe_arena_release_metadata(); + + private: + const ::subspace::ClientBufferHandleMetadataProto& _internal_metadata() const; + ::subspace::ClientBufferHandleMetadataProto* _internal_mutable_metadata(); + + public: + // @@protoc_insertion_point(class_scope:subspace.RegisterClientBufferRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RegisterClientBufferRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::subspace::ClientBufferHandleMetadataProto* metadata_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Discovery final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Discovery) */ { + public: + inline Discovery() : Discovery(nullptr) {} + ~Discovery() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Discovery* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Discovery)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Discovery( + ::google::protobuf::internal::ConstantInitialized); + + inline Discovery(const Discovery& from) : Discovery(nullptr, from) {} + inline Discovery(Discovery&& from) noexcept + : Discovery(nullptr, std::move(from)) {} + inline Discovery& operator=(const Discovery& from) { + CopyFrom(from); + return *this; + } + inline Discovery& operator=(Discovery&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Discovery& default_instance() { + return *internal_default_instance(); + } + enum DataCase { + kQuery = 3, + kAdvertise = 4, + kSubscribe = 5, + DATA_NOT_SET = 0, + }; + static inline const Discovery* internal_default_instance() { + return reinterpret_cast( + &_Discovery_default_instance_); + } + static constexpr int kIndexInFileMessages = 31; + friend void swap(Discovery& a, Discovery& b) { a.Swap(&b); } + inline void Swap(Discovery* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Discovery* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Discovery* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Discovery& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Discovery& from) { Discovery::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Discovery* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Discovery"; } + + protected: + explicit Discovery(::google::protobuf::Arena* arena); + Discovery(::google::protobuf::Arena* arena, const Discovery& from); + Discovery(::google::protobuf::Arena* arena, Discovery&& from) noexcept + : Discovery(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using Query = Discovery_Query; + using Advertise = Discovery_Advertise; + using Subscribe = Discovery_Subscribe; + + // accessors ------------------------------------------------------- + enum : int { + kServerIdFieldNumber = 1, + kPortFieldNumber = 2, + kQueryFieldNumber = 3, + kAdvertiseFieldNumber = 4, + kSubscribeFieldNumber = 5, + }; + // string server_id = 1; + void clear_server_id() ; + const std::string& server_id() const; + template + void set_server_id(Arg_&& arg, Args_... args); + std::string* mutable_server_id(); + PROTOBUF_NODISCARD std::string* release_server_id(); + void set_allocated_server_id(std::string* value); + + private: + const std::string& _internal_server_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id( + const std::string& value); + std::string* _internal_mutable_server_id(); + + public: + // int32 port = 2; + void clear_port() ; + ::int32_t port() const; + void set_port(::int32_t value); + + private: + ::int32_t _internal_port() const; + void _internal_set_port(::int32_t value); + + public: + // .subspace.Discovery.Query query = 3; + bool has_query() const; + private: + bool _internal_has_query() const; + + public: + void clear_query() ; + const ::subspace::Discovery_Query& query() const; + PROTOBUF_NODISCARD ::subspace::Discovery_Query* release_query(); + ::subspace::Discovery_Query* mutable_query(); + void set_allocated_query(::subspace::Discovery_Query* value); + void unsafe_arena_set_allocated_query(::subspace::Discovery_Query* value); + ::subspace::Discovery_Query* unsafe_arena_release_query(); + + private: + const ::subspace::Discovery_Query& _internal_query() const; + ::subspace::Discovery_Query* _internal_mutable_query(); + + public: + // .subspace.Discovery.Advertise advertise = 4; + bool has_advertise() const; + private: + bool _internal_has_advertise() const; + + public: + void clear_advertise() ; + const ::subspace::Discovery_Advertise& advertise() const; + PROTOBUF_NODISCARD ::subspace::Discovery_Advertise* release_advertise(); + ::subspace::Discovery_Advertise* mutable_advertise(); + void set_allocated_advertise(::subspace::Discovery_Advertise* value); + void unsafe_arena_set_allocated_advertise(::subspace::Discovery_Advertise* value); + ::subspace::Discovery_Advertise* unsafe_arena_release_advertise(); + + private: + const ::subspace::Discovery_Advertise& _internal_advertise() const; + ::subspace::Discovery_Advertise* _internal_mutable_advertise(); + + public: + // .subspace.Discovery.Subscribe subscribe = 5; + bool has_subscribe() const; + private: + bool _internal_has_subscribe() const; + + public: + void clear_subscribe() ; + const ::subspace::Discovery_Subscribe& subscribe() const; + PROTOBUF_NODISCARD ::subspace::Discovery_Subscribe* release_subscribe(); + ::subspace::Discovery_Subscribe* mutable_subscribe(); + void set_allocated_subscribe(::subspace::Discovery_Subscribe* value); + void unsafe_arena_set_allocated_subscribe(::subspace::Discovery_Subscribe* value); + ::subspace::Discovery_Subscribe* unsafe_arena_release_subscribe(); + + private: + const ::subspace::Discovery_Subscribe& _internal_subscribe() const; + ::subspace::Discovery_Subscribe* _internal_mutable_subscribe(); + + public: + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:subspace.Discovery) + private: + class _Internal; + void set_has_query(); + void set_has_advertise(); + void set_has_subscribe(); + inline bool has_data() const; + inline void clear_has_data(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 5, 3, + 36, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Discovery& from_msg); + ::google::protobuf::internal::ArenaStringPtr server_id_; + ::int32_t port_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::subspace::Discovery_Query* query_; + ::subspace::Discovery_Advertise* advertise_; + ::subspace::Discovery_Subscribe* subscribe_; + } data_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class ShadowEvent final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.ShadowEvent) */ { + public: + inline ShadowEvent() : ShadowEvent(nullptr) {} + ~ShadowEvent() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ShadowEvent* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ShadowEvent)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ShadowEvent( + ::google::protobuf::internal::ConstantInitialized); + + inline ShadowEvent(const ShadowEvent& from) : ShadowEvent(nullptr, from) {} + inline ShadowEvent(ShadowEvent&& from) noexcept + : ShadowEvent(nullptr, std::move(from)) {} + inline ShadowEvent& operator=(const ShadowEvent& from) { + CopyFrom(from); + return *this; + } + inline ShadowEvent& operator=(ShadowEvent&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ShadowEvent& default_instance() { + return *internal_default_instance(); + } + enum EventCase { + kInit = 1, + kCreateChannel = 2, + kRemoveChannel = 3, + kAddPublisher = 4, + kRemovePublisher = 5, + kAddSubscriber = 6, + kRemoveSubscriber = 7, + kStateDump = 8, + kStateDone = 9, + kRegisterClientBuffer = 10, + kUnregisterClientBuffer = 11, + kUpdateChannelOptions = 12, + EVENT_NOT_SET = 0, + }; + static inline const ShadowEvent* internal_default_instance() { + return reinterpret_cast( + &_ShadowEvent_default_instance_); + } + static constexpr int kIndexInFileMessages = 46; + friend void swap(ShadowEvent& a, ShadowEvent& b) { a.Swap(&b); } + inline void Swap(ShadowEvent* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ShadowEvent* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ShadowEvent* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ShadowEvent& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ShadowEvent& from) { ShadowEvent::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ShadowEvent* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.ShadowEvent"; } + + protected: + explicit ShadowEvent(::google::protobuf::Arena* arena); + ShadowEvent(::google::protobuf::Arena* arena, const ShadowEvent& from); + ShadowEvent(::google::protobuf::Arena* arena, ShadowEvent&& from) noexcept + : ShadowEvent(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kInitFieldNumber = 1, + kCreateChannelFieldNumber = 2, + kRemoveChannelFieldNumber = 3, + kAddPublisherFieldNumber = 4, + kRemovePublisherFieldNumber = 5, + kAddSubscriberFieldNumber = 6, + kRemoveSubscriberFieldNumber = 7, + kStateDumpFieldNumber = 8, + kStateDoneFieldNumber = 9, + kRegisterClientBufferFieldNumber = 10, + kUnregisterClientBufferFieldNumber = 11, + kUpdateChannelOptionsFieldNumber = 12, + }; + // .subspace.ShadowInit init = 1; + bool has_init() const; + private: + bool _internal_has_init() const; + + public: + void clear_init() ; + const ::subspace::ShadowInit& init() const; + PROTOBUF_NODISCARD ::subspace::ShadowInit* release_init(); + ::subspace::ShadowInit* mutable_init(); + void set_allocated_init(::subspace::ShadowInit* value); + void unsafe_arena_set_allocated_init(::subspace::ShadowInit* value); + ::subspace::ShadowInit* unsafe_arena_release_init(); + + private: + const ::subspace::ShadowInit& _internal_init() const; + ::subspace::ShadowInit* _internal_mutable_init(); + + public: + // .subspace.ShadowCreateChannel create_channel = 2; + bool has_create_channel() const; + private: + bool _internal_has_create_channel() const; + + public: + void clear_create_channel() ; + const ::subspace::ShadowCreateChannel& create_channel() const; + PROTOBUF_NODISCARD ::subspace::ShadowCreateChannel* release_create_channel(); + ::subspace::ShadowCreateChannel* mutable_create_channel(); + void set_allocated_create_channel(::subspace::ShadowCreateChannel* value); + void unsafe_arena_set_allocated_create_channel(::subspace::ShadowCreateChannel* value); + ::subspace::ShadowCreateChannel* unsafe_arena_release_create_channel(); + + private: + const ::subspace::ShadowCreateChannel& _internal_create_channel() const; + ::subspace::ShadowCreateChannel* _internal_mutable_create_channel(); + + public: + // .subspace.ShadowRemoveChannel remove_channel = 3; + bool has_remove_channel() const; + private: + bool _internal_has_remove_channel() const; + + public: + void clear_remove_channel() ; + const ::subspace::ShadowRemoveChannel& remove_channel() const; + PROTOBUF_NODISCARD ::subspace::ShadowRemoveChannel* release_remove_channel(); + ::subspace::ShadowRemoveChannel* mutable_remove_channel(); + void set_allocated_remove_channel(::subspace::ShadowRemoveChannel* value); + void unsafe_arena_set_allocated_remove_channel(::subspace::ShadowRemoveChannel* value); + ::subspace::ShadowRemoveChannel* unsafe_arena_release_remove_channel(); + + private: + const ::subspace::ShadowRemoveChannel& _internal_remove_channel() const; + ::subspace::ShadowRemoveChannel* _internal_mutable_remove_channel(); + + public: + // .subspace.ShadowAddPublisher add_publisher = 4; + bool has_add_publisher() const; + private: + bool _internal_has_add_publisher() const; + + public: + void clear_add_publisher() ; + const ::subspace::ShadowAddPublisher& add_publisher() const; + PROTOBUF_NODISCARD ::subspace::ShadowAddPublisher* release_add_publisher(); + ::subspace::ShadowAddPublisher* mutable_add_publisher(); + void set_allocated_add_publisher(::subspace::ShadowAddPublisher* value); + void unsafe_arena_set_allocated_add_publisher(::subspace::ShadowAddPublisher* value); + ::subspace::ShadowAddPublisher* unsafe_arena_release_add_publisher(); + + private: + const ::subspace::ShadowAddPublisher& _internal_add_publisher() const; + ::subspace::ShadowAddPublisher* _internal_mutable_add_publisher(); + + public: + // .subspace.ShadowRemovePublisher remove_publisher = 5; + bool has_remove_publisher() const; + private: + bool _internal_has_remove_publisher() const; + + public: + void clear_remove_publisher() ; + const ::subspace::ShadowRemovePublisher& remove_publisher() const; + PROTOBUF_NODISCARD ::subspace::ShadowRemovePublisher* release_remove_publisher(); + ::subspace::ShadowRemovePublisher* mutable_remove_publisher(); + void set_allocated_remove_publisher(::subspace::ShadowRemovePublisher* value); + void unsafe_arena_set_allocated_remove_publisher(::subspace::ShadowRemovePublisher* value); + ::subspace::ShadowRemovePublisher* unsafe_arena_release_remove_publisher(); + + private: + const ::subspace::ShadowRemovePublisher& _internal_remove_publisher() const; + ::subspace::ShadowRemovePublisher* _internal_mutable_remove_publisher(); + + public: + // .subspace.ShadowAddSubscriber add_subscriber = 6; + bool has_add_subscriber() const; + private: + bool _internal_has_add_subscriber() const; + + public: + void clear_add_subscriber() ; + const ::subspace::ShadowAddSubscriber& add_subscriber() const; + PROTOBUF_NODISCARD ::subspace::ShadowAddSubscriber* release_add_subscriber(); + ::subspace::ShadowAddSubscriber* mutable_add_subscriber(); + void set_allocated_add_subscriber(::subspace::ShadowAddSubscriber* value); + void unsafe_arena_set_allocated_add_subscriber(::subspace::ShadowAddSubscriber* value); + ::subspace::ShadowAddSubscriber* unsafe_arena_release_add_subscriber(); + + private: + const ::subspace::ShadowAddSubscriber& _internal_add_subscriber() const; + ::subspace::ShadowAddSubscriber* _internal_mutable_add_subscriber(); + + public: + // .subspace.ShadowRemoveSubscriber remove_subscriber = 7; + bool has_remove_subscriber() const; + private: + bool _internal_has_remove_subscriber() const; + + public: + void clear_remove_subscriber() ; + const ::subspace::ShadowRemoveSubscriber& remove_subscriber() const; + PROTOBUF_NODISCARD ::subspace::ShadowRemoveSubscriber* release_remove_subscriber(); + ::subspace::ShadowRemoveSubscriber* mutable_remove_subscriber(); + void set_allocated_remove_subscriber(::subspace::ShadowRemoveSubscriber* value); + void unsafe_arena_set_allocated_remove_subscriber(::subspace::ShadowRemoveSubscriber* value); + ::subspace::ShadowRemoveSubscriber* unsafe_arena_release_remove_subscriber(); + + private: + const ::subspace::ShadowRemoveSubscriber& _internal_remove_subscriber() const; + ::subspace::ShadowRemoveSubscriber* _internal_mutable_remove_subscriber(); + + public: + // .subspace.ShadowStateDump state_dump = 8; + bool has_state_dump() const; + private: + bool _internal_has_state_dump() const; + + public: + void clear_state_dump() ; + const ::subspace::ShadowStateDump& state_dump() const; + PROTOBUF_NODISCARD ::subspace::ShadowStateDump* release_state_dump(); + ::subspace::ShadowStateDump* mutable_state_dump(); + void set_allocated_state_dump(::subspace::ShadowStateDump* value); + void unsafe_arena_set_allocated_state_dump(::subspace::ShadowStateDump* value); + ::subspace::ShadowStateDump* unsafe_arena_release_state_dump(); + + private: + const ::subspace::ShadowStateDump& _internal_state_dump() const; + ::subspace::ShadowStateDump* _internal_mutable_state_dump(); + + public: + // .subspace.ShadowStateDone state_done = 9; + bool has_state_done() const; + private: + bool _internal_has_state_done() const; + + public: + void clear_state_done() ; + const ::subspace::ShadowStateDone& state_done() const; + PROTOBUF_NODISCARD ::subspace::ShadowStateDone* release_state_done(); + ::subspace::ShadowStateDone* mutable_state_done(); + void set_allocated_state_done(::subspace::ShadowStateDone* value); + void unsafe_arena_set_allocated_state_done(::subspace::ShadowStateDone* value); + ::subspace::ShadowStateDone* unsafe_arena_release_state_done(); + + private: + const ::subspace::ShadowStateDone& _internal_state_done() const; + ::subspace::ShadowStateDone* _internal_mutable_state_done(); + + public: + // .subspace.ShadowRegisterClientBuffer register_client_buffer = 10; + bool has_register_client_buffer() const; + private: + bool _internal_has_register_client_buffer() const; + + public: + void clear_register_client_buffer() ; + const ::subspace::ShadowRegisterClientBuffer& register_client_buffer() const; + PROTOBUF_NODISCARD ::subspace::ShadowRegisterClientBuffer* release_register_client_buffer(); + ::subspace::ShadowRegisterClientBuffer* mutable_register_client_buffer(); + void set_allocated_register_client_buffer(::subspace::ShadowRegisterClientBuffer* value); + void unsafe_arena_set_allocated_register_client_buffer(::subspace::ShadowRegisterClientBuffer* value); + ::subspace::ShadowRegisterClientBuffer* unsafe_arena_release_register_client_buffer(); + + private: + const ::subspace::ShadowRegisterClientBuffer& _internal_register_client_buffer() const; + ::subspace::ShadowRegisterClientBuffer* _internal_mutable_register_client_buffer(); + + public: + // .subspace.ShadowUnregisterClientBuffer unregister_client_buffer = 11; + bool has_unregister_client_buffer() const; + private: + bool _internal_has_unregister_client_buffer() const; + + public: + void clear_unregister_client_buffer() ; + const ::subspace::ShadowUnregisterClientBuffer& unregister_client_buffer() const; + PROTOBUF_NODISCARD ::subspace::ShadowUnregisterClientBuffer* release_unregister_client_buffer(); + ::subspace::ShadowUnregisterClientBuffer* mutable_unregister_client_buffer(); + void set_allocated_unregister_client_buffer(::subspace::ShadowUnregisterClientBuffer* value); + void unsafe_arena_set_allocated_unregister_client_buffer(::subspace::ShadowUnregisterClientBuffer* value); + ::subspace::ShadowUnregisterClientBuffer* unsafe_arena_release_unregister_client_buffer(); + + private: + const ::subspace::ShadowUnregisterClientBuffer& _internal_unregister_client_buffer() const; + ::subspace::ShadowUnregisterClientBuffer* _internal_mutable_unregister_client_buffer(); + + public: + // .subspace.ShadowUpdateChannelOptions update_channel_options = 12; + bool has_update_channel_options() const; + private: + bool _internal_has_update_channel_options() const; + + public: + void clear_update_channel_options() ; + const ::subspace::ShadowUpdateChannelOptions& update_channel_options() const; + PROTOBUF_NODISCARD ::subspace::ShadowUpdateChannelOptions* release_update_channel_options(); + ::subspace::ShadowUpdateChannelOptions* mutable_update_channel_options(); + void set_allocated_update_channel_options(::subspace::ShadowUpdateChannelOptions* value); + void unsafe_arena_set_allocated_update_channel_options(::subspace::ShadowUpdateChannelOptions* value); + ::subspace::ShadowUpdateChannelOptions* unsafe_arena_release_update_channel_options(); + + private: + const ::subspace::ShadowUpdateChannelOptions& _internal_update_channel_options() const; + ::subspace::ShadowUpdateChannelOptions* _internal_mutable_update_channel_options(); + + public: + void clear_event(); + EventCase event_case() const; + // @@protoc_insertion_point(class_scope:subspace.ShadowEvent) + private: + class _Internal; + void set_has_init(); + void set_has_create_channel(); + void set_has_remove_channel(); + void set_has_add_publisher(); + void set_has_remove_publisher(); + void set_has_add_subscriber(); + void set_has_remove_subscriber(); + void set_has_state_dump(); + void set_has_state_done(); + void set_has_register_client_buffer(); + void set_has_unregister_client_buffer(); + void set_has_update_channel_options(); + inline bool has_event() const; + inline void clear_has_event(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 12, 12, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ShadowEvent& from_msg); + union EventUnion { + constexpr EventUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::subspace::ShadowInit* init_; + ::subspace::ShadowCreateChannel* create_channel_; + ::subspace::ShadowRemoveChannel* remove_channel_; + ::subspace::ShadowAddPublisher* add_publisher_; + ::subspace::ShadowRemovePublisher* remove_publisher_; + ::subspace::ShadowAddSubscriber* add_subscriber_; + ::subspace::ShadowRemoveSubscriber* remove_subscriber_; + ::subspace::ShadowStateDump* state_dump_; + ::subspace::ShadowStateDone* state_done_; + ::subspace::ShadowRegisterClientBuffer* register_client_buffer_; + ::subspace::ShadowUnregisterClientBuffer* unregister_client_buffer_; + ::subspace::ShadowUpdateChannelOptions* update_channel_options_; + } event_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class RpcServerResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.RpcServerResponse) */ { + public: + inline RpcServerResponse() : RpcServerResponse(nullptr) {} + ~RpcServerResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcServerResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcServerResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RpcServerResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline RpcServerResponse(const RpcServerResponse& from) : RpcServerResponse(nullptr, from) {} + inline RpcServerResponse(RpcServerResponse&& from) noexcept + : RpcServerResponse(nullptr, std::move(from)) {} + inline RpcServerResponse& operator=(const RpcServerResponse& from) { + CopyFrom(from); + return *this; + } + inline RpcServerResponse& operator=(RpcServerResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RpcServerResponse& default_instance() { + return *internal_default_instance(); + } + enum ResponseCase { + kOpen = 3, + kClose = 4, + RESPONSE_NOT_SET = 0, + }; + static inline const RpcServerResponse* internal_default_instance() { + return reinterpret_cast( + &_RpcServerResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 40; + friend void swap(RpcServerResponse& a, RpcServerResponse& b) { a.Swap(&b); } + inline void Swap(RpcServerResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RpcServerResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RpcServerResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RpcServerResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RpcServerResponse& from) { RpcServerResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcServerResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.RpcServerResponse"; } + + protected: + explicit RpcServerResponse(::google::protobuf::Arena* arena); + RpcServerResponse(::google::protobuf::Arena* arena, const RpcServerResponse& from); + RpcServerResponse(::google::protobuf::Arena* arena, RpcServerResponse&& from) noexcept + : RpcServerResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kErrorFieldNumber = 5, + kClientIdFieldNumber = 1, + kRequestIdFieldNumber = 2, + kOpenFieldNumber = 3, + kCloseFieldNumber = 4, + }; + // string error = 5; + void clear_error() ; + const std::string& error() const; + template + void set_error(Arg_&& arg, Args_... args); + std::string* mutable_error(); + PROTOBUF_NODISCARD std::string* release_error(); + void set_allocated_error(std::string* value); + + private: + const std::string& _internal_error() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_error( + const std::string& value); + std::string* _internal_mutable_error(); + + public: + // uint64 client_id = 1; + void clear_client_id() ; + ::uint64_t client_id() const; + void set_client_id(::uint64_t value); + + private: + ::uint64_t _internal_client_id() const; + void _internal_set_client_id(::uint64_t value); + + public: + // int32 request_id = 2; + void clear_request_id() ; + ::int32_t request_id() const; + void set_request_id(::int32_t value); + + private: + ::int32_t _internal_request_id() const; + void _internal_set_request_id(::int32_t value); + + public: + // .subspace.RpcOpenResponse open = 3; + bool has_open() const; + private: + bool _internal_has_open() const; + + public: + void clear_open() ; + const ::subspace::RpcOpenResponse& open() const; + PROTOBUF_NODISCARD ::subspace::RpcOpenResponse* release_open(); + ::subspace::RpcOpenResponse* mutable_open(); + void set_allocated_open(::subspace::RpcOpenResponse* value); + void unsafe_arena_set_allocated_open(::subspace::RpcOpenResponse* value); + ::subspace::RpcOpenResponse* unsafe_arena_release_open(); + + private: + const ::subspace::RpcOpenResponse& _internal_open() const; + ::subspace::RpcOpenResponse* _internal_mutable_open(); + + public: + // .subspace.RpcCloseResponse close = 4; + bool has_close() const; + private: + bool _internal_has_close() const; + + public: + void clear_close() ; + const ::subspace::RpcCloseResponse& close() const; + PROTOBUF_NODISCARD ::subspace::RpcCloseResponse* release_close(); + ::subspace::RpcCloseResponse* mutable_close(); + void set_allocated_close(::subspace::RpcCloseResponse* value); + void unsafe_arena_set_allocated_close(::subspace::RpcCloseResponse* value); + ::subspace::RpcCloseResponse* unsafe_arena_release_close(); + + private: + const ::subspace::RpcCloseResponse& _internal_close() const; + ::subspace::RpcCloseResponse* _internal_mutable_close(); + + public: + void clear_response(); + ResponseCase response_case() const; + // @@protoc_insertion_point(class_scope:subspace.RpcServerResponse) + private: + class _Internal; + void set_has_open(); + void set_has_close(); + inline bool has_response() const; + inline void clear_has_response(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 5, 2, + 40, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RpcServerResponse& from_msg); + ::google::protobuf::internal::ArenaStringPtr error_; + ::uint64_t client_id_; + ::int32_t request_id_; + union ResponseUnion { + constexpr ResponseUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::subspace::RpcOpenResponse* open_; + ::subspace::RpcCloseResponse* close_; + } response_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; +// ------------------------------------------------------------------- + +class Request final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:subspace.Request) */ { + public: + inline Request() : Request(nullptr) {} + ~Request() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Request* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Request)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Request( + ::google::protobuf::internal::ConstantInitialized); + + inline Request(const Request& from) : Request(nullptr, from) {} + inline Request(Request&& from) noexcept + : Request(nullptr, std::move(from)) {} + inline Request& operator=(const Request& from) { + CopyFrom(from); + return *this; + } + inline Request& operator=(Request&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Request& default_instance() { + return *internal_default_instance(); + } + enum RequestCase { + kInit = 1, + kCreatePublisher = 2, + kCreateSubscriber = 3, + kGetTriggers = 4, + kRemovePublisher = 5, + kRemoveSubscriber = 6, + kGetChannelInfo = 9, + kGetChannelStats = 10, + kRegisterClientBuffer = 11, + kUnregisterClientBuffer = 12, + REQUEST_NOT_SET = 0, + }; + static inline const Request* internal_default_instance() { + return reinterpret_cast( + &_Request_default_instance_); + } + static constexpr int kIndexInFileMessages = 19; + friend void swap(Request& a, Request& b) { a.Swap(&b); } + inline void Swap(Request* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Request* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Request* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Request& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Request& from) { Request::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Request* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "subspace.Request"; } + + protected: + explicit Request(::google::protobuf::Arena* arena); + Request(::google::protobuf::Arena* arena, const Request& from); + Request(::google::protobuf::Arena* arena, Request&& from) noexcept + : Request(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kInitFieldNumber = 1, + kCreatePublisherFieldNumber = 2, + kCreateSubscriberFieldNumber = 3, + kGetTriggersFieldNumber = 4, + kRemovePublisherFieldNumber = 5, + kRemoveSubscriberFieldNumber = 6, + kGetChannelInfoFieldNumber = 9, + kGetChannelStatsFieldNumber = 10, + kRegisterClientBufferFieldNumber = 11, + kUnregisterClientBufferFieldNumber = 12, + }; + // .subspace.InitRequest init = 1; + bool has_init() const; + private: + bool _internal_has_init() const; + + public: + void clear_init() ; + const ::subspace::InitRequest& init() const; + PROTOBUF_NODISCARD ::subspace::InitRequest* release_init(); + ::subspace::InitRequest* mutable_init(); + void set_allocated_init(::subspace::InitRequest* value); + void unsafe_arena_set_allocated_init(::subspace::InitRequest* value); + ::subspace::InitRequest* unsafe_arena_release_init(); + + private: + const ::subspace::InitRequest& _internal_init() const; + ::subspace::InitRequest* _internal_mutable_init(); + + public: + // .subspace.CreatePublisherRequest create_publisher = 2; + bool has_create_publisher() const; + private: + bool _internal_has_create_publisher() const; + + public: + void clear_create_publisher() ; + const ::subspace::CreatePublisherRequest& create_publisher() const; + PROTOBUF_NODISCARD ::subspace::CreatePublisherRequest* release_create_publisher(); + ::subspace::CreatePublisherRequest* mutable_create_publisher(); + void set_allocated_create_publisher(::subspace::CreatePublisherRequest* value); + void unsafe_arena_set_allocated_create_publisher(::subspace::CreatePublisherRequest* value); + ::subspace::CreatePublisherRequest* unsafe_arena_release_create_publisher(); + + private: + const ::subspace::CreatePublisherRequest& _internal_create_publisher() const; + ::subspace::CreatePublisherRequest* _internal_mutable_create_publisher(); + + public: + // .subspace.CreateSubscriberRequest create_subscriber = 3; + bool has_create_subscriber() const; + private: + bool _internal_has_create_subscriber() const; + + public: + void clear_create_subscriber() ; + const ::subspace::CreateSubscriberRequest& create_subscriber() const; + PROTOBUF_NODISCARD ::subspace::CreateSubscriberRequest* release_create_subscriber(); + ::subspace::CreateSubscriberRequest* mutable_create_subscriber(); + void set_allocated_create_subscriber(::subspace::CreateSubscriberRequest* value); + void unsafe_arena_set_allocated_create_subscriber(::subspace::CreateSubscriberRequest* value); + ::subspace::CreateSubscriberRequest* unsafe_arena_release_create_subscriber(); + + private: + const ::subspace::CreateSubscriberRequest& _internal_create_subscriber() const; + ::subspace::CreateSubscriberRequest* _internal_mutable_create_subscriber(); + + public: + // .subspace.GetTriggersRequest get_triggers = 4; + bool has_get_triggers() const; + private: + bool _internal_has_get_triggers() const; + + public: + void clear_get_triggers() ; + const ::subspace::GetTriggersRequest& get_triggers() const; + PROTOBUF_NODISCARD ::subspace::GetTriggersRequest* release_get_triggers(); + ::subspace::GetTriggersRequest* mutable_get_triggers(); + void set_allocated_get_triggers(::subspace::GetTriggersRequest* value); + void unsafe_arena_set_allocated_get_triggers(::subspace::GetTriggersRequest* value); + ::subspace::GetTriggersRequest* unsafe_arena_release_get_triggers(); + + private: + const ::subspace::GetTriggersRequest& _internal_get_triggers() const; + ::subspace::GetTriggersRequest* _internal_mutable_get_triggers(); + + public: + // .subspace.RemovePublisherRequest remove_publisher = 5; + bool has_remove_publisher() const; + private: + bool _internal_has_remove_publisher() const; + + public: + void clear_remove_publisher() ; + const ::subspace::RemovePublisherRequest& remove_publisher() const; + PROTOBUF_NODISCARD ::subspace::RemovePublisherRequest* release_remove_publisher(); + ::subspace::RemovePublisherRequest* mutable_remove_publisher(); + void set_allocated_remove_publisher(::subspace::RemovePublisherRequest* value); + void unsafe_arena_set_allocated_remove_publisher(::subspace::RemovePublisherRequest* value); + ::subspace::RemovePublisherRequest* unsafe_arena_release_remove_publisher(); + + private: + const ::subspace::RemovePublisherRequest& _internal_remove_publisher() const; + ::subspace::RemovePublisherRequest* _internal_mutable_remove_publisher(); + + public: + // .subspace.RemoveSubscriberRequest remove_subscriber = 6; + bool has_remove_subscriber() const; + private: + bool _internal_has_remove_subscriber() const; + + public: + void clear_remove_subscriber() ; + const ::subspace::RemoveSubscriberRequest& remove_subscriber() const; + PROTOBUF_NODISCARD ::subspace::RemoveSubscriberRequest* release_remove_subscriber(); + ::subspace::RemoveSubscriberRequest* mutable_remove_subscriber(); + void set_allocated_remove_subscriber(::subspace::RemoveSubscriberRequest* value); + void unsafe_arena_set_allocated_remove_subscriber(::subspace::RemoveSubscriberRequest* value); + ::subspace::RemoveSubscriberRequest* unsafe_arena_release_remove_subscriber(); + + private: + const ::subspace::RemoveSubscriberRequest& _internal_remove_subscriber() const; + ::subspace::RemoveSubscriberRequest* _internal_mutable_remove_subscriber(); + + public: + // .subspace.GetChannelInfoRequest get_channel_info = 9; + bool has_get_channel_info() const; + private: + bool _internal_has_get_channel_info() const; + + public: + void clear_get_channel_info() ; + const ::subspace::GetChannelInfoRequest& get_channel_info() const; + PROTOBUF_NODISCARD ::subspace::GetChannelInfoRequest* release_get_channel_info(); + ::subspace::GetChannelInfoRequest* mutable_get_channel_info(); + void set_allocated_get_channel_info(::subspace::GetChannelInfoRequest* value); + void unsafe_arena_set_allocated_get_channel_info(::subspace::GetChannelInfoRequest* value); + ::subspace::GetChannelInfoRequest* unsafe_arena_release_get_channel_info(); + + private: + const ::subspace::GetChannelInfoRequest& _internal_get_channel_info() const; + ::subspace::GetChannelInfoRequest* _internal_mutable_get_channel_info(); + + public: + // .subspace.GetChannelStatsRequest get_channel_stats = 10; + bool has_get_channel_stats() const; + private: + bool _internal_has_get_channel_stats() const; + + public: + void clear_get_channel_stats() ; + const ::subspace::GetChannelStatsRequest& get_channel_stats() const; + PROTOBUF_NODISCARD ::subspace::GetChannelStatsRequest* release_get_channel_stats(); + ::subspace::GetChannelStatsRequest* mutable_get_channel_stats(); + void set_allocated_get_channel_stats(::subspace::GetChannelStatsRequest* value); + void unsafe_arena_set_allocated_get_channel_stats(::subspace::GetChannelStatsRequest* value); + ::subspace::GetChannelStatsRequest* unsafe_arena_release_get_channel_stats(); + + private: + const ::subspace::GetChannelStatsRequest& _internal_get_channel_stats() const; + ::subspace::GetChannelStatsRequest* _internal_mutable_get_channel_stats(); + + public: + // .subspace.RegisterClientBufferRequest register_client_buffer = 11; + bool has_register_client_buffer() const; + private: + bool _internal_has_register_client_buffer() const; + + public: + void clear_register_client_buffer() ; + const ::subspace::RegisterClientBufferRequest& register_client_buffer() const; + PROTOBUF_NODISCARD ::subspace::RegisterClientBufferRequest* release_register_client_buffer(); + ::subspace::RegisterClientBufferRequest* mutable_register_client_buffer(); + void set_allocated_register_client_buffer(::subspace::RegisterClientBufferRequest* value); + void unsafe_arena_set_allocated_register_client_buffer(::subspace::RegisterClientBufferRequest* value); + ::subspace::RegisterClientBufferRequest* unsafe_arena_release_register_client_buffer(); + + private: + const ::subspace::RegisterClientBufferRequest& _internal_register_client_buffer() const; + ::subspace::RegisterClientBufferRequest* _internal_mutable_register_client_buffer(); + + public: + // .subspace.UnregisterClientBufferRequest unregister_client_buffer = 12; + bool has_unregister_client_buffer() const; + private: + bool _internal_has_unregister_client_buffer() const; + + public: + void clear_unregister_client_buffer() ; + const ::subspace::UnregisterClientBufferRequest& unregister_client_buffer() const; + PROTOBUF_NODISCARD ::subspace::UnregisterClientBufferRequest* release_unregister_client_buffer(); + ::subspace::UnregisterClientBufferRequest* mutable_unregister_client_buffer(); + void set_allocated_unregister_client_buffer(::subspace::UnregisterClientBufferRequest* value); + void unsafe_arena_set_allocated_unregister_client_buffer(::subspace::UnregisterClientBufferRequest* value); + ::subspace::UnregisterClientBufferRequest* unsafe_arena_release_unregister_client_buffer(); + + private: + const ::subspace::UnregisterClientBufferRequest& _internal_unregister_client_buffer() const; + ::subspace::UnregisterClientBufferRequest* _internal_mutable_unregister_client_buffer(); + + public: + void clear_request(); + RequestCase request_case() const; + // @@protoc_insertion_point(class_scope:subspace.Request) + private: + class _Internal; + void set_has_init(); + void set_has_create_publisher(); + void set_has_create_subscriber(); + void set_has_get_triggers(); + void set_has_remove_publisher(); + void set_has_remove_subscriber(); + void set_has_get_channel_info(); + void set_has_get_channel_stats(); + void set_has_register_client_buffer(); + void set_has_unregister_client_buffer(); + inline bool has_request() const; + inline void clear_has_request(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 10, 10, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Request& from_msg); + union RequestUnion { + constexpr RequestUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::subspace::InitRequest* init_; + ::subspace::CreatePublisherRequest* create_publisher_; + ::subspace::CreateSubscriberRequest* create_subscriber_; + ::subspace::GetTriggersRequest* get_triggers_; + ::subspace::RemovePublisherRequest* remove_publisher_; + ::subspace::RemoveSubscriberRequest* remove_subscriber_; + ::subspace::GetChannelInfoRequest* get_channel_info_; + ::subspace::GetChannelStatsRequest* get_channel_stats_; + ::subspace::RegisterClientBufferRequest* register_client_buffer_; + ::subspace::UnregisterClientBufferRequest* unregister_client_buffer_; + } request_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_subspace_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// InitRequest + +// string client_name = 1; +inline void InitRequest::clear_client_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_name_.ClearToEmpty(); +} +inline const std::string& InitRequest::client_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.InitRequest.client_name) + return _internal_client_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void InitRequest::set_client_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.InitRequest.client_name) +} +inline std::string* InitRequest::mutable_client_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_client_name(); + // @@protoc_insertion_point(field_mutable:subspace.InitRequest.client_name) + return _s; +} +inline const std::string& InitRequest::_internal_client_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_name_.Get(); +} +inline void InitRequest::_internal_set_client_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_name_.Set(value, GetArena()); +} +inline std::string* InitRequest::_internal_mutable_client_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.client_name_.Mutable( GetArena()); +} +inline std::string* InitRequest::release_client_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.InitRequest.client_name) + return _impl_.client_name_.Release(); +} +inline void InitRequest::set_allocated_client_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.client_name_.IsDefault()) { + _impl_.client_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.InitRequest.client_name) +} + +// ------------------------------------------------------------------- + +// InitResponse + +// int32 scb_fd_index = 1; +inline void InitResponse::clear_scb_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.scb_fd_index_ = 0; +} +inline ::int32_t InitResponse::scb_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.InitResponse.scb_fd_index) + return _internal_scb_fd_index(); +} +inline void InitResponse::set_scb_fd_index(::int32_t value) { + _internal_set_scb_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.InitResponse.scb_fd_index) +} +inline ::int32_t InitResponse::_internal_scb_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.scb_fd_index_; +} +inline void InitResponse::_internal_set_scb_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.scb_fd_index_ = value; +} + +// int64 session_id = 2; +inline void InitResponse::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = ::int64_t{0}; +} +inline ::int64_t InitResponse::session_id() const { + // @@protoc_insertion_point(field_get:subspace.InitResponse.session_id) + return _internal_session_id(); +} +inline void InitResponse::set_session_id(::int64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.InitResponse.session_id) +} +inline ::int64_t InitResponse::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void InitResponse::_internal_set_session_id(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// int32 user_id = 3; +inline void InitResponse::clear_user_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.user_id_ = 0; +} +inline ::int32_t InitResponse::user_id() const { + // @@protoc_insertion_point(field_get:subspace.InitResponse.user_id) + return _internal_user_id(); +} +inline void InitResponse::set_user_id(::int32_t value) { + _internal_set_user_id(value); + // @@protoc_insertion_point(field_set:subspace.InitResponse.user_id) +} +inline ::int32_t InitResponse::_internal_user_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.user_id_; +} +inline void InitResponse::_internal_set_user_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.user_id_ = value; +} + +// int32 group_id = 4; +inline void InitResponse::clear_group_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.group_id_ = 0; +} +inline ::int32_t InitResponse::group_id() const { + // @@protoc_insertion_point(field_get:subspace.InitResponse.group_id) + return _internal_group_id(); +} +inline void InitResponse::set_group_id(::int32_t value) { + _internal_set_group_id(value); + // @@protoc_insertion_point(field_set:subspace.InitResponse.group_id) +} +inline ::int32_t InitResponse::_internal_group_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.group_id_; +} +inline void InitResponse::_internal_set_group_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.group_id_ = value; +} + +// ------------------------------------------------------------------- + +// CreatePublisherRequest + +// string channel_name = 1; +inline void CreatePublisherRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& CreatePublisherRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreatePublisherRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.channel_name) +} +inline std::string* CreatePublisherRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.CreatePublisherRequest.channel_name) + return _s; +} +inline const std::string& CreatePublisherRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void CreatePublisherRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* CreatePublisherRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* CreatePublisherRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreatePublisherRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void CreatePublisherRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreatePublisherRequest.channel_name) +} + +// int32 num_slots = 2; +inline void CreatePublisherRequest::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t CreatePublisherRequest::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.num_slots) + return _internal_num_slots(); +} +inline void CreatePublisherRequest::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.num_slots) +} +inline ::int32_t CreatePublisherRequest::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void CreatePublisherRequest::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// int32 slot_size = 3; +inline void CreatePublisherRequest::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t CreatePublisherRequest::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.slot_size) + return _internal_slot_size(); +} +inline void CreatePublisherRequest::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.slot_size) +} +inline ::int32_t CreatePublisherRequest::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void CreatePublisherRequest::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// bool is_local = 4; +inline void CreatePublisherRequest::clear_is_local() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_local_ = false; +} +inline bool CreatePublisherRequest::is_local() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.is_local) + return _internal_is_local(); +} +inline void CreatePublisherRequest::set_is_local(bool value) { + _internal_set_is_local(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.is_local) +} +inline bool CreatePublisherRequest::_internal_is_local() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_local_; +} +inline void CreatePublisherRequest::_internal_set_is_local(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_local_ = value; +} + +// bool is_reliable = 5; +inline void CreatePublisherRequest::clear_is_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = false; +} +inline bool CreatePublisherRequest::is_reliable() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.is_reliable) + return _internal_is_reliable(); +} +inline void CreatePublisherRequest::set_is_reliable(bool value) { + _internal_set_is_reliable(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.is_reliable) +} +inline bool CreatePublisherRequest::_internal_is_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_reliable_; +} +inline void CreatePublisherRequest::_internal_set_is_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = value; +} + +// bool is_bridge = 6; +inline void CreatePublisherRequest::clear_is_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = false; +} +inline bool CreatePublisherRequest::is_bridge() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.is_bridge) + return _internal_is_bridge(); +} +inline void CreatePublisherRequest::set_is_bridge(bool value) { + _internal_set_is_bridge(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.is_bridge) +} +inline bool CreatePublisherRequest::_internal_is_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_bridge_; +} +inline void CreatePublisherRequest::_internal_set_is_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = value; +} + +// bytes type = 7; +inline void CreatePublisherRequest::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& CreatePublisherRequest::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreatePublisherRequest::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.type) +} +inline std::string* CreatePublisherRequest::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.CreatePublisherRequest.type) + return _s; +} +inline const std::string& CreatePublisherRequest::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void CreatePublisherRequest::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* CreatePublisherRequest::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* CreatePublisherRequest::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreatePublisherRequest.type) + return _impl_.type_.Release(); +} +inline void CreatePublisherRequest::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreatePublisherRequest.type) +} + +// bool is_fixed_size = 8; +inline void CreatePublisherRequest::clear_is_fixed_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_fixed_size_ = false; +} +inline bool CreatePublisherRequest::is_fixed_size() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.is_fixed_size) + return _internal_is_fixed_size(); +} +inline void CreatePublisherRequest::set_is_fixed_size(bool value) { + _internal_set_is_fixed_size(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.is_fixed_size) +} +inline bool CreatePublisherRequest::_internal_is_fixed_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_fixed_size_; +} +inline void CreatePublisherRequest::_internal_set_is_fixed_size(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_fixed_size_ = value; +} + +// bool for_tunnel = 15; +inline void CreatePublisherRequest::clear_for_tunnel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = false; +} +inline bool CreatePublisherRequest::for_tunnel() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.for_tunnel) + return _internal_for_tunnel(); +} +inline void CreatePublisherRequest::set_for_tunnel(bool value) { + _internal_set_for_tunnel(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.for_tunnel) +} +inline bool CreatePublisherRequest::_internal_for_tunnel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.for_tunnel_; +} +inline void CreatePublisherRequest::_internal_set_for_tunnel(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = value; +} + +// string mux = 9; +inline void CreatePublisherRequest::clear_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.ClearToEmpty(); +} +inline const std::string& CreatePublisherRequest::mux() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.mux) + return _internal_mux(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreatePublisherRequest::set_mux(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.mux) +} +inline std::string* CreatePublisherRequest::mutable_mux() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_mux(); + // @@protoc_insertion_point(field_mutable:subspace.CreatePublisherRequest.mux) + return _s; +} +inline const std::string& CreatePublisherRequest::_internal_mux() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.mux_.Get(); +} +inline void CreatePublisherRequest::_internal_set_mux(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(value, GetArena()); +} +inline std::string* CreatePublisherRequest::_internal_mutable_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.mux_.Mutable( GetArena()); +} +inline std::string* CreatePublisherRequest::release_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreatePublisherRequest.mux) + return _impl_.mux_.Release(); +} +inline void CreatePublisherRequest::set_allocated_mux(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.mux_.IsDefault()) { + _impl_.mux_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreatePublisherRequest.mux) +} + +// int32 vchan_id = 10; +inline void CreatePublisherRequest::clear_vchan_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = 0; +} +inline ::int32_t CreatePublisherRequest::vchan_id() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.vchan_id) + return _internal_vchan_id(); +} +inline void CreatePublisherRequest::set_vchan_id(::int32_t value) { + _internal_set_vchan_id(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.vchan_id) +} +inline ::int32_t CreatePublisherRequest::_internal_vchan_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vchan_id_; +} +inline void CreatePublisherRequest::_internal_set_vchan_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = value; +} + +// bool notify_retirement = 11; +inline void CreatePublisherRequest::clear_notify_retirement() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = false; +} +inline bool CreatePublisherRequest::notify_retirement() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.notify_retirement) + return _internal_notify_retirement(); +} +inline void CreatePublisherRequest::set_notify_retirement(bool value) { + _internal_set_notify_retirement(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.notify_retirement) +} +inline bool CreatePublisherRequest::_internal_notify_retirement() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.notify_retirement_; +} +inline void CreatePublisherRequest::_internal_set_notify_retirement(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = value; +} + +// int32 checksum_size = 12; +inline void CreatePublisherRequest::clear_checksum_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = 0; +} +inline ::int32_t CreatePublisherRequest::checksum_size() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.checksum_size) + return _internal_checksum_size(); +} +inline void CreatePublisherRequest::set_checksum_size(::int32_t value) { + _internal_set_checksum_size(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.checksum_size) +} +inline ::int32_t CreatePublisherRequest::_internal_checksum_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.checksum_size_; +} +inline void CreatePublisherRequest::_internal_set_checksum_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = value; +} + +// int32 metadata_size = 13; +inline void CreatePublisherRequest::clear_metadata_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = 0; +} +inline ::int32_t CreatePublisherRequest::metadata_size() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.metadata_size) + return _internal_metadata_size(); +} +inline void CreatePublisherRequest::set_metadata_size(::int32_t value) { + _internal_set_metadata_size(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.metadata_size) +} +inline ::int32_t CreatePublisherRequest::_internal_metadata_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.metadata_size_; +} +inline void CreatePublisherRequest::_internal_set_metadata_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = value; +} + +// int32 publisher_id = 14; +inline void CreatePublisherRequest::clear_publisher_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = 0; +} +inline ::int32_t CreatePublisherRequest::publisher_id() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.publisher_id) + return _internal_publisher_id(); +} +inline void CreatePublisherRequest::set_publisher_id(::int32_t value) { + _internal_set_publisher_id(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.publisher_id) +} +inline ::int32_t CreatePublisherRequest::_internal_publisher_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.publisher_id_; +} +inline void CreatePublisherRequest::_internal_set_publisher_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = value; +} + +// bool use_split_buffers = 16; +inline void CreatePublisherRequest::clear_use_split_buffers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = false; +} +inline bool CreatePublisherRequest::use_split_buffers() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.use_split_buffers) + return _internal_use_split_buffers(); +} +inline void CreatePublisherRequest::set_use_split_buffers(bool value) { + _internal_set_use_split_buffers(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.use_split_buffers) +} +inline bool CreatePublisherRequest::_internal_use_split_buffers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.use_split_buffers_; +} +inline void CreatePublisherRequest::_internal_set_use_split_buffers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = value; +} + +// int32 max_publishers = 17; +inline void CreatePublisherRequest::clear_max_publishers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_publishers_ = 0; +} +inline ::int32_t CreatePublisherRequest::max_publishers() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.max_publishers) + return _internal_max_publishers(); +} +inline void CreatePublisherRequest::set_max_publishers(::int32_t value) { + _internal_set_max_publishers(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.max_publishers) +} +inline ::int32_t CreatePublisherRequest::_internal_max_publishers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_publishers_; +} +inline void CreatePublisherRequest::_internal_set_max_publishers(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_publishers_ = value; +} + +// bool split_buffers_over_bridge = 18; +inline void CreatePublisherRequest::clear_split_buffers_over_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = false; +} +inline bool CreatePublisherRequest::split_buffers_over_bridge() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherRequest.split_buffers_over_bridge) + return _internal_split_buffers_over_bridge(); +} +inline void CreatePublisherRequest::set_split_buffers_over_bridge(bool value) { + _internal_set_split_buffers_over_bridge(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherRequest.split_buffers_over_bridge) +} +inline bool CreatePublisherRequest::_internal_split_buffers_over_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.split_buffers_over_bridge_; +} +inline void CreatePublisherRequest::_internal_set_split_buffers_over_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = value; +} + +// ------------------------------------------------------------------- + +// CreatePublisherResponse + +// string error = 1; +inline void CreatePublisherResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& CreatePublisherResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreatePublisherResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.error) +} +inline std::string* CreatePublisherResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.CreatePublisherResponse.error) + return _s; +} +inline const std::string& CreatePublisherResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void CreatePublisherResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* CreatePublisherResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* CreatePublisherResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreatePublisherResponse.error) + return _impl_.error_.Release(); +} +inline void CreatePublisherResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreatePublisherResponse.error) +} + +// int32 channel_id = 2; +inline void CreatePublisherResponse::clear_channel_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = 0; +} +inline ::int32_t CreatePublisherResponse::channel_id() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.channel_id) + return _internal_channel_id(); +} +inline void CreatePublisherResponse::set_channel_id(::int32_t value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.channel_id) +} +inline ::int32_t CreatePublisherResponse::_internal_channel_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_id_; +} +inline void CreatePublisherResponse::_internal_set_channel_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = value; +} + +// int32 publisher_id = 3; +inline void CreatePublisherResponse::clear_publisher_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = 0; +} +inline ::int32_t CreatePublisherResponse::publisher_id() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.publisher_id) + return _internal_publisher_id(); +} +inline void CreatePublisherResponse::set_publisher_id(::int32_t value) { + _internal_set_publisher_id(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.publisher_id) +} +inline ::int32_t CreatePublisherResponse::_internal_publisher_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.publisher_id_; +} +inline void CreatePublisherResponse::_internal_set_publisher_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = value; +} + +// int32 ccb_fd_index = 4; +inline void CreatePublisherResponse::clear_ccb_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.ccb_fd_index_ = 0; +} +inline ::int32_t CreatePublisherResponse::ccb_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.ccb_fd_index) + return _internal_ccb_fd_index(); +} +inline void CreatePublisherResponse::set_ccb_fd_index(::int32_t value) { + _internal_set_ccb_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.ccb_fd_index) +} +inline ::int32_t CreatePublisherResponse::_internal_ccb_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.ccb_fd_index_; +} +inline void CreatePublisherResponse::_internal_set_ccb_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.ccb_fd_index_ = value; +} + +// int32 bcb_fd_index = 5; +inline void CreatePublisherResponse::clear_bcb_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.bcb_fd_index_ = 0; +} +inline ::int32_t CreatePublisherResponse::bcb_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.bcb_fd_index) + return _internal_bcb_fd_index(); +} +inline void CreatePublisherResponse::set_bcb_fd_index(::int32_t value) { + _internal_set_bcb_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.bcb_fd_index) +} +inline ::int32_t CreatePublisherResponse::_internal_bcb_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.bcb_fd_index_; +} +inline void CreatePublisherResponse::_internal_set_bcb_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.bcb_fd_index_ = value; +} + +// int32 pub_poll_fd_index = 6; +inline void CreatePublisherResponse::clear_pub_poll_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pub_poll_fd_index_ = 0; +} +inline ::int32_t CreatePublisherResponse::pub_poll_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.pub_poll_fd_index) + return _internal_pub_poll_fd_index(); +} +inline void CreatePublisherResponse::set_pub_poll_fd_index(::int32_t value) { + _internal_set_pub_poll_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.pub_poll_fd_index) +} +inline ::int32_t CreatePublisherResponse::_internal_pub_poll_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pub_poll_fd_index_; +} +inline void CreatePublisherResponse::_internal_set_pub_poll_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pub_poll_fd_index_ = value; +} + +// int32 pub_trigger_fd_index = 7; +inline void CreatePublisherResponse::clear_pub_trigger_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pub_trigger_fd_index_ = 0; +} +inline ::int32_t CreatePublisherResponse::pub_trigger_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.pub_trigger_fd_index) + return _internal_pub_trigger_fd_index(); +} +inline void CreatePublisherResponse::set_pub_trigger_fd_index(::int32_t value) { + _internal_set_pub_trigger_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.pub_trigger_fd_index) +} +inline ::int32_t CreatePublisherResponse::_internal_pub_trigger_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pub_trigger_fd_index_; +} +inline void CreatePublisherResponse::_internal_set_pub_trigger_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pub_trigger_fd_index_ = value; +} + +// repeated int32 sub_trigger_fd_indexes = 8; +inline int CreatePublisherResponse::_internal_sub_trigger_fd_indexes_size() const { + return _internal_sub_trigger_fd_indexes().size(); +} +inline int CreatePublisherResponse::sub_trigger_fd_indexes_size() const { + return _internal_sub_trigger_fd_indexes_size(); +} +inline void CreatePublisherResponse::clear_sub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sub_trigger_fd_indexes_.Clear(); +} +inline ::int32_t CreatePublisherResponse::sub_trigger_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.sub_trigger_fd_indexes) + return _internal_sub_trigger_fd_indexes().Get(index); +} +inline void CreatePublisherResponse::set_sub_trigger_fd_indexes(int index, ::int32_t value) { + _internal_mutable_sub_trigger_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.sub_trigger_fd_indexes) +} +inline void CreatePublisherResponse::add_sub_trigger_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_sub_trigger_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.CreatePublisherResponse.sub_trigger_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& CreatePublisherResponse::sub_trigger_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.CreatePublisherResponse.sub_trigger_fd_indexes) + return _internal_sub_trigger_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreatePublisherResponse::mutable_sub_trigger_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.CreatePublisherResponse.sub_trigger_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_sub_trigger_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +CreatePublisherResponse::_internal_sub_trigger_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.sub_trigger_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreatePublisherResponse::_internal_mutable_sub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.sub_trigger_fd_indexes_; +} + +// int32 num_sub_updates = 9; +inline void CreatePublisherResponse::clear_num_sub_updates() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_sub_updates_ = 0; +} +inline ::int32_t CreatePublisherResponse::num_sub_updates() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.num_sub_updates) + return _internal_num_sub_updates(); +} +inline void CreatePublisherResponse::set_num_sub_updates(::int32_t value) { + _internal_set_num_sub_updates(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.num_sub_updates) +} +inline ::int32_t CreatePublisherResponse::_internal_num_sub_updates() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_sub_updates_; +} +inline void CreatePublisherResponse::_internal_set_num_sub_updates(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_sub_updates_ = value; +} + +// bytes type = 10; +inline void CreatePublisherResponse::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& CreatePublisherResponse::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreatePublisherResponse::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.type) +} +inline std::string* CreatePublisherResponse::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.CreatePublisherResponse.type) + return _s; +} +inline const std::string& CreatePublisherResponse::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void CreatePublisherResponse::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* CreatePublisherResponse::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* CreatePublisherResponse::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreatePublisherResponse.type) + return _impl_.type_.Release(); +} +inline void CreatePublisherResponse::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreatePublisherResponse.type) +} + +// int32 vchan_id = 11; +inline void CreatePublisherResponse::clear_vchan_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = 0; +} +inline ::int32_t CreatePublisherResponse::vchan_id() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.vchan_id) + return _internal_vchan_id(); +} +inline void CreatePublisherResponse::set_vchan_id(::int32_t value) { + _internal_set_vchan_id(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.vchan_id) +} +inline ::int32_t CreatePublisherResponse::_internal_vchan_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vchan_id_; +} +inline void CreatePublisherResponse::_internal_set_vchan_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = value; +} + +// int32 retirement_fd_index = 14; +inline void CreatePublisherResponse::clear_retirement_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.retirement_fd_index_ = 0; +} +inline ::int32_t CreatePublisherResponse::retirement_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.retirement_fd_index) + return _internal_retirement_fd_index(); +} +inline void CreatePublisherResponse::set_retirement_fd_index(::int32_t value) { + _internal_set_retirement_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.retirement_fd_index) +} +inline ::int32_t CreatePublisherResponse::_internal_retirement_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.retirement_fd_index_; +} +inline void CreatePublisherResponse::_internal_set_retirement_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.retirement_fd_index_ = value; +} + +// repeated int32 retirement_fd_indexes = 15; +inline int CreatePublisherResponse::_internal_retirement_fd_indexes_size() const { + return _internal_retirement_fd_indexes().size(); +} +inline int CreatePublisherResponse::retirement_fd_indexes_size() const { + return _internal_retirement_fd_indexes_size(); +} +inline void CreatePublisherResponse::clear_retirement_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.retirement_fd_indexes_.Clear(); +} +inline ::int32_t CreatePublisherResponse::retirement_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.CreatePublisherResponse.retirement_fd_indexes) + return _internal_retirement_fd_indexes().Get(index); +} +inline void CreatePublisherResponse::set_retirement_fd_indexes(int index, ::int32_t value) { + _internal_mutable_retirement_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.CreatePublisherResponse.retirement_fd_indexes) +} +inline void CreatePublisherResponse::add_retirement_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_retirement_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.CreatePublisherResponse.retirement_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& CreatePublisherResponse::retirement_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.CreatePublisherResponse.retirement_fd_indexes) + return _internal_retirement_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreatePublisherResponse::mutable_retirement_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.CreatePublisherResponse.retirement_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_retirement_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +CreatePublisherResponse::_internal_retirement_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.retirement_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreatePublisherResponse::_internal_mutable_retirement_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.retirement_fd_indexes_; +} + +// ------------------------------------------------------------------- + +// CreateSubscriberRequest + +// string channel_name = 1; +inline void CreateSubscriberRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& CreateSubscriberRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreateSubscriberRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.channel_name) +} +inline std::string* CreateSubscriberRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.CreateSubscriberRequest.channel_name) + return _s; +} +inline const std::string& CreateSubscriberRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void CreateSubscriberRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* CreateSubscriberRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* CreateSubscriberRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreateSubscriberRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void CreateSubscriberRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreateSubscriberRequest.channel_name) +} + +// int32 subscriber_id = 2; +inline void CreateSubscriberRequest::clear_subscriber_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = 0; +} +inline ::int32_t CreateSubscriberRequest::subscriber_id() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.subscriber_id) + return _internal_subscriber_id(); +} +inline void CreateSubscriberRequest::set_subscriber_id(::int32_t value) { + _internal_set_subscriber_id(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.subscriber_id) +} +inline ::int32_t CreateSubscriberRequest::_internal_subscriber_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.subscriber_id_; +} +inline void CreateSubscriberRequest::_internal_set_subscriber_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = value; +} + +// bool is_reliable = 3; +inline void CreateSubscriberRequest::clear_is_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = false; +} +inline bool CreateSubscriberRequest::is_reliable() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.is_reliable) + return _internal_is_reliable(); +} +inline void CreateSubscriberRequest::set_is_reliable(bool value) { + _internal_set_is_reliable(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.is_reliable) +} +inline bool CreateSubscriberRequest::_internal_is_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_reliable_; +} +inline void CreateSubscriberRequest::_internal_set_is_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = value; +} + +// bool is_bridge = 4; +inline void CreateSubscriberRequest::clear_is_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = false; +} +inline bool CreateSubscriberRequest::is_bridge() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.is_bridge) + return _internal_is_bridge(); +} +inline void CreateSubscriberRequest::set_is_bridge(bool value) { + _internal_set_is_bridge(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.is_bridge) +} +inline bool CreateSubscriberRequest::_internal_is_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_bridge_; +} +inline void CreateSubscriberRequest::_internal_set_is_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = value; +} + +// bytes type = 5; +inline void CreateSubscriberRequest::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& CreateSubscriberRequest::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreateSubscriberRequest::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.type) +} +inline std::string* CreateSubscriberRequest::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.CreateSubscriberRequest.type) + return _s; +} +inline const std::string& CreateSubscriberRequest::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void CreateSubscriberRequest::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* CreateSubscriberRequest::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* CreateSubscriberRequest::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreateSubscriberRequest.type) + return _impl_.type_.Release(); +} +inline void CreateSubscriberRequest::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreateSubscriberRequest.type) +} + +// int32 max_active_messages = 6; +inline void CreateSubscriberRequest::clear_max_active_messages() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_active_messages_ = 0; +} +inline ::int32_t CreateSubscriberRequest::max_active_messages() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.max_active_messages) + return _internal_max_active_messages(); +} +inline void CreateSubscriberRequest::set_max_active_messages(::int32_t value) { + _internal_set_max_active_messages(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.max_active_messages) +} +inline ::int32_t CreateSubscriberRequest::_internal_max_active_messages() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_active_messages_; +} +inline void CreateSubscriberRequest::_internal_set_max_active_messages(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_active_messages_ = value; +} + +// bool for_tunnel = 9; +inline void CreateSubscriberRequest::clear_for_tunnel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = false; +} +inline bool CreateSubscriberRequest::for_tunnel() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.for_tunnel) + return _internal_for_tunnel(); +} +inline void CreateSubscriberRequest::set_for_tunnel(bool value) { + _internal_set_for_tunnel(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.for_tunnel) +} +inline bool CreateSubscriberRequest::_internal_for_tunnel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.for_tunnel_; +} +inline void CreateSubscriberRequest::_internal_set_for_tunnel(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = value; +} + +// string mux = 7; +inline void CreateSubscriberRequest::clear_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.ClearToEmpty(); +} +inline const std::string& CreateSubscriberRequest::mux() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.mux) + return _internal_mux(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreateSubscriberRequest::set_mux(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.mux) +} +inline std::string* CreateSubscriberRequest::mutable_mux() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_mux(); + // @@protoc_insertion_point(field_mutable:subspace.CreateSubscriberRequest.mux) + return _s; +} +inline const std::string& CreateSubscriberRequest::_internal_mux() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.mux_.Get(); +} +inline void CreateSubscriberRequest::_internal_set_mux(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(value, GetArena()); +} +inline std::string* CreateSubscriberRequest::_internal_mutable_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.mux_.Mutable( GetArena()); +} +inline std::string* CreateSubscriberRequest::release_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreateSubscriberRequest.mux) + return _impl_.mux_.Release(); +} +inline void CreateSubscriberRequest::set_allocated_mux(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.mux_.IsDefault()) { + _impl_.mux_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreateSubscriberRequest.mux) +} + +// int32 vchan_id = 8; +inline void CreateSubscriberRequest::clear_vchan_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = 0; +} +inline ::int32_t CreateSubscriberRequest::vchan_id() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberRequest.vchan_id) + return _internal_vchan_id(); +} +inline void CreateSubscriberRequest::set_vchan_id(::int32_t value) { + _internal_set_vchan_id(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberRequest.vchan_id) +} +inline ::int32_t CreateSubscriberRequest::_internal_vchan_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vchan_id_; +} +inline void CreateSubscriberRequest::_internal_set_vchan_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = value; +} + +// ------------------------------------------------------------------- + +// CreateSubscriberResponse + +// string error = 1; +inline void CreateSubscriberResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& CreateSubscriberResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreateSubscriberResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.error) +} +inline std::string* CreateSubscriberResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.CreateSubscriberResponse.error) + return _s; +} +inline const std::string& CreateSubscriberResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void CreateSubscriberResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* CreateSubscriberResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* CreateSubscriberResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreateSubscriberResponse.error) + return _impl_.error_.Release(); +} +inline void CreateSubscriberResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreateSubscriberResponse.error) +} + +// int32 channel_id = 2; +inline void CreateSubscriberResponse::clear_channel_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = 0; +} +inline ::int32_t CreateSubscriberResponse::channel_id() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.channel_id) + return _internal_channel_id(); +} +inline void CreateSubscriberResponse::set_channel_id(::int32_t value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.channel_id) +} +inline ::int32_t CreateSubscriberResponse::_internal_channel_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_id_; +} +inline void CreateSubscriberResponse::_internal_set_channel_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = value; +} + +// int32 subscriber_id = 3; +inline void CreateSubscriberResponse::clear_subscriber_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = 0; +} +inline ::int32_t CreateSubscriberResponse::subscriber_id() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.subscriber_id) + return _internal_subscriber_id(); +} +inline void CreateSubscriberResponse::set_subscriber_id(::int32_t value) { + _internal_set_subscriber_id(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.subscriber_id) +} +inline ::int32_t CreateSubscriberResponse::_internal_subscriber_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.subscriber_id_; +} +inline void CreateSubscriberResponse::_internal_set_subscriber_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = value; +} + +// int32 ccb_fd_index = 4; +inline void CreateSubscriberResponse::clear_ccb_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.ccb_fd_index_ = 0; +} +inline ::int32_t CreateSubscriberResponse::ccb_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.ccb_fd_index) + return _internal_ccb_fd_index(); +} +inline void CreateSubscriberResponse::set_ccb_fd_index(::int32_t value) { + _internal_set_ccb_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.ccb_fd_index) +} +inline ::int32_t CreateSubscriberResponse::_internal_ccb_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.ccb_fd_index_; +} +inline void CreateSubscriberResponse::_internal_set_ccb_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.ccb_fd_index_ = value; +} + +// int32 bcb_fd_index = 5; +inline void CreateSubscriberResponse::clear_bcb_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.bcb_fd_index_ = 0; +} +inline ::int32_t CreateSubscriberResponse::bcb_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.bcb_fd_index) + return _internal_bcb_fd_index(); +} +inline void CreateSubscriberResponse::set_bcb_fd_index(::int32_t value) { + _internal_set_bcb_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.bcb_fd_index) +} +inline ::int32_t CreateSubscriberResponse::_internal_bcb_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.bcb_fd_index_; +} +inline void CreateSubscriberResponse::_internal_set_bcb_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.bcb_fd_index_ = value; +} + +// int32 trigger_fd_index = 6; +inline void CreateSubscriberResponse::clear_trigger_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.trigger_fd_index_ = 0; +} +inline ::int32_t CreateSubscriberResponse::trigger_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.trigger_fd_index) + return _internal_trigger_fd_index(); +} +inline void CreateSubscriberResponse::set_trigger_fd_index(::int32_t value) { + _internal_set_trigger_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.trigger_fd_index) +} +inline ::int32_t CreateSubscriberResponse::_internal_trigger_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.trigger_fd_index_; +} +inline void CreateSubscriberResponse::_internal_set_trigger_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.trigger_fd_index_ = value; +} + +// int32 poll_fd_index = 7; +inline void CreateSubscriberResponse::clear_poll_fd_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.poll_fd_index_ = 0; +} +inline ::int32_t CreateSubscriberResponse::poll_fd_index() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.poll_fd_index) + return _internal_poll_fd_index(); +} +inline void CreateSubscriberResponse::set_poll_fd_index(::int32_t value) { + _internal_set_poll_fd_index(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.poll_fd_index) +} +inline ::int32_t CreateSubscriberResponse::_internal_poll_fd_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.poll_fd_index_; +} +inline void CreateSubscriberResponse::_internal_set_poll_fd_index(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.poll_fd_index_ = value; +} + +// int32 slot_size = 8; +inline void CreateSubscriberResponse::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t CreateSubscriberResponse::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.slot_size) + return _internal_slot_size(); +} +inline void CreateSubscriberResponse::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.slot_size) +} +inline ::int32_t CreateSubscriberResponse::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void CreateSubscriberResponse::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// int32 num_slots = 9; +inline void CreateSubscriberResponse::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t CreateSubscriberResponse::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.num_slots) + return _internal_num_slots(); +} +inline void CreateSubscriberResponse::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.num_slots) +} +inline ::int32_t CreateSubscriberResponse::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void CreateSubscriberResponse::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// repeated int32 reliable_pub_trigger_fd_indexes = 10; +inline int CreateSubscriberResponse::_internal_reliable_pub_trigger_fd_indexes_size() const { + return _internal_reliable_pub_trigger_fd_indexes().size(); +} +inline int CreateSubscriberResponse::reliable_pub_trigger_fd_indexes_size() const { + return _internal_reliable_pub_trigger_fd_indexes_size(); +} +inline void CreateSubscriberResponse::clear_reliable_pub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_pub_trigger_fd_indexes_.Clear(); +} +inline ::int32_t CreateSubscriberResponse::reliable_pub_trigger_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.reliable_pub_trigger_fd_indexes) + return _internal_reliable_pub_trigger_fd_indexes().Get(index); +} +inline void CreateSubscriberResponse::set_reliable_pub_trigger_fd_indexes(int index, ::int32_t value) { + _internal_mutable_reliable_pub_trigger_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.reliable_pub_trigger_fd_indexes) +} +inline void CreateSubscriberResponse::add_reliable_pub_trigger_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_reliable_pub_trigger_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.CreateSubscriberResponse.reliable_pub_trigger_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& CreateSubscriberResponse::reliable_pub_trigger_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.CreateSubscriberResponse.reliable_pub_trigger_fd_indexes) + return _internal_reliable_pub_trigger_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreateSubscriberResponse::mutable_reliable_pub_trigger_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.CreateSubscriberResponse.reliable_pub_trigger_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_reliable_pub_trigger_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +CreateSubscriberResponse::_internal_reliable_pub_trigger_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reliable_pub_trigger_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreateSubscriberResponse::_internal_mutable_reliable_pub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.reliable_pub_trigger_fd_indexes_; +} + +// int32 num_pub_updates = 11; +inline void CreateSubscriberResponse::clear_num_pub_updates() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_pub_updates_ = 0; +} +inline ::int32_t CreateSubscriberResponse::num_pub_updates() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.num_pub_updates) + return _internal_num_pub_updates(); +} +inline void CreateSubscriberResponse::set_num_pub_updates(::int32_t value) { + _internal_set_num_pub_updates(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.num_pub_updates) +} +inline ::int32_t CreateSubscriberResponse::_internal_num_pub_updates() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_pub_updates_; +} +inline void CreateSubscriberResponse::_internal_set_num_pub_updates(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_pub_updates_ = value; +} + +// bytes type = 12; +inline void CreateSubscriberResponse::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& CreateSubscriberResponse::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void CreateSubscriberResponse::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.type) +} +inline std::string* CreateSubscriberResponse::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.CreateSubscriberResponse.type) + return _s; +} +inline const std::string& CreateSubscriberResponse::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void CreateSubscriberResponse::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* CreateSubscriberResponse::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* CreateSubscriberResponse::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.CreateSubscriberResponse.type) + return _impl_.type_.Release(); +} +inline void CreateSubscriberResponse::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.CreateSubscriberResponse.type) +} + +// int32 vchan_id = 13; +inline void CreateSubscriberResponse::clear_vchan_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = 0; +} +inline ::int32_t CreateSubscriberResponse::vchan_id() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.vchan_id) + return _internal_vchan_id(); +} +inline void CreateSubscriberResponse::set_vchan_id(::int32_t value) { + _internal_set_vchan_id(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.vchan_id) +} +inline ::int32_t CreateSubscriberResponse::_internal_vchan_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vchan_id_; +} +inline void CreateSubscriberResponse::_internal_set_vchan_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = value; +} + +// repeated int32 retirement_fd_indexes = 14; +inline int CreateSubscriberResponse::_internal_retirement_fd_indexes_size() const { + return _internal_retirement_fd_indexes().size(); +} +inline int CreateSubscriberResponse::retirement_fd_indexes_size() const { + return _internal_retirement_fd_indexes_size(); +} +inline void CreateSubscriberResponse::clear_retirement_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.retirement_fd_indexes_.Clear(); +} +inline ::int32_t CreateSubscriberResponse::retirement_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.retirement_fd_indexes) + return _internal_retirement_fd_indexes().Get(index); +} +inline void CreateSubscriberResponse::set_retirement_fd_indexes(int index, ::int32_t value) { + _internal_mutable_retirement_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.retirement_fd_indexes) +} +inline void CreateSubscriberResponse::add_retirement_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_retirement_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.CreateSubscriberResponse.retirement_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& CreateSubscriberResponse::retirement_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.CreateSubscriberResponse.retirement_fd_indexes) + return _internal_retirement_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreateSubscriberResponse::mutable_retirement_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.CreateSubscriberResponse.retirement_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_retirement_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +CreateSubscriberResponse::_internal_retirement_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.retirement_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* CreateSubscriberResponse::_internal_mutable_retirement_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.retirement_fd_indexes_; +} + +// int32 checksum_size = 15; +inline void CreateSubscriberResponse::clear_checksum_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = 0; +} +inline ::int32_t CreateSubscriberResponse::checksum_size() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.checksum_size) + return _internal_checksum_size(); +} +inline void CreateSubscriberResponse::set_checksum_size(::int32_t value) { + _internal_set_checksum_size(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.checksum_size) +} +inline ::int32_t CreateSubscriberResponse::_internal_checksum_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.checksum_size_; +} +inline void CreateSubscriberResponse::_internal_set_checksum_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = value; +} + +// int32 metadata_size = 16; +inline void CreateSubscriberResponse::clear_metadata_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = 0; +} +inline ::int32_t CreateSubscriberResponse::metadata_size() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.metadata_size) + return _internal_metadata_size(); +} +inline void CreateSubscriberResponse::set_metadata_size(::int32_t value) { + _internal_set_metadata_size(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.metadata_size) +} +inline ::int32_t CreateSubscriberResponse::_internal_metadata_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.metadata_size_; +} +inline void CreateSubscriberResponse::_internal_set_metadata_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = value; +} + +// bool use_split_buffers = 17; +inline void CreateSubscriberResponse::clear_use_split_buffers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = false; +} +inline bool CreateSubscriberResponse::use_split_buffers() const { + // @@protoc_insertion_point(field_get:subspace.CreateSubscriberResponse.use_split_buffers) + return _internal_use_split_buffers(); +} +inline void CreateSubscriberResponse::set_use_split_buffers(bool value) { + _internal_set_use_split_buffers(value); + // @@protoc_insertion_point(field_set:subspace.CreateSubscriberResponse.use_split_buffers) +} +inline bool CreateSubscriberResponse::_internal_use_split_buffers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.use_split_buffers_; +} +inline void CreateSubscriberResponse::_internal_set_use_split_buffers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = value; +} + +// ------------------------------------------------------------------- + +// GetTriggersRequest + +// string channel_name = 1; +inline void GetTriggersRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& GetTriggersRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetTriggersRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GetTriggersRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.GetTriggersRequest.channel_name) +} +inline std::string* GetTriggersRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.GetTriggersRequest.channel_name) + return _s; +} +inline const std::string& GetTriggersRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void GetTriggersRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* GetTriggersRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* GetTriggersRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.GetTriggersRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void GetTriggersRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.GetTriggersRequest.channel_name) +} + +// ------------------------------------------------------------------- + +// GetTriggersResponse + +// string error = 1; +inline void GetTriggersResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& GetTriggersResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetTriggersResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GetTriggersResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.GetTriggersResponse.error) +} +inline std::string* GetTriggersResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.GetTriggersResponse.error) + return _s; +} +inline const std::string& GetTriggersResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void GetTriggersResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* GetTriggersResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* GetTriggersResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.GetTriggersResponse.error) + return _impl_.error_.Release(); +} +inline void GetTriggersResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.GetTriggersResponse.error) +} + +// repeated int32 reliable_pub_trigger_fd_indexes = 2; +inline int GetTriggersResponse::_internal_reliable_pub_trigger_fd_indexes_size() const { + return _internal_reliable_pub_trigger_fd_indexes().size(); +} +inline int GetTriggersResponse::reliable_pub_trigger_fd_indexes_size() const { + return _internal_reliable_pub_trigger_fd_indexes_size(); +} +inline void GetTriggersResponse::clear_reliable_pub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_pub_trigger_fd_indexes_.Clear(); +} +inline ::int32_t GetTriggersResponse::reliable_pub_trigger_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.GetTriggersResponse.reliable_pub_trigger_fd_indexes) + return _internal_reliable_pub_trigger_fd_indexes().Get(index); +} +inline void GetTriggersResponse::set_reliable_pub_trigger_fd_indexes(int index, ::int32_t value) { + _internal_mutable_reliable_pub_trigger_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.GetTriggersResponse.reliable_pub_trigger_fd_indexes) +} +inline void GetTriggersResponse::add_reliable_pub_trigger_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_reliable_pub_trigger_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.GetTriggersResponse.reliable_pub_trigger_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& GetTriggersResponse::reliable_pub_trigger_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.GetTriggersResponse.reliable_pub_trigger_fd_indexes) + return _internal_reliable_pub_trigger_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* GetTriggersResponse::mutable_reliable_pub_trigger_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.GetTriggersResponse.reliable_pub_trigger_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_reliable_pub_trigger_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +GetTriggersResponse::_internal_reliable_pub_trigger_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reliable_pub_trigger_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* GetTriggersResponse::_internal_mutable_reliable_pub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.reliable_pub_trigger_fd_indexes_; +} + +// repeated int32 sub_trigger_fd_indexes = 3; +inline int GetTriggersResponse::_internal_sub_trigger_fd_indexes_size() const { + return _internal_sub_trigger_fd_indexes().size(); +} +inline int GetTriggersResponse::sub_trigger_fd_indexes_size() const { + return _internal_sub_trigger_fd_indexes_size(); +} +inline void GetTriggersResponse::clear_sub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sub_trigger_fd_indexes_.Clear(); +} +inline ::int32_t GetTriggersResponse::sub_trigger_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.GetTriggersResponse.sub_trigger_fd_indexes) + return _internal_sub_trigger_fd_indexes().Get(index); +} +inline void GetTriggersResponse::set_sub_trigger_fd_indexes(int index, ::int32_t value) { + _internal_mutable_sub_trigger_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.GetTriggersResponse.sub_trigger_fd_indexes) +} +inline void GetTriggersResponse::add_sub_trigger_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_sub_trigger_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.GetTriggersResponse.sub_trigger_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& GetTriggersResponse::sub_trigger_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.GetTriggersResponse.sub_trigger_fd_indexes) + return _internal_sub_trigger_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* GetTriggersResponse::mutable_sub_trigger_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.GetTriggersResponse.sub_trigger_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_sub_trigger_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +GetTriggersResponse::_internal_sub_trigger_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.sub_trigger_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* GetTriggersResponse::_internal_mutable_sub_trigger_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.sub_trigger_fd_indexes_; +} + +// repeated int32 retirement_fd_indexes = 4; +inline int GetTriggersResponse::_internal_retirement_fd_indexes_size() const { + return _internal_retirement_fd_indexes().size(); +} +inline int GetTriggersResponse::retirement_fd_indexes_size() const { + return _internal_retirement_fd_indexes_size(); +} +inline void GetTriggersResponse::clear_retirement_fd_indexes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.retirement_fd_indexes_.Clear(); +} +inline ::int32_t GetTriggersResponse::retirement_fd_indexes(int index) const { + // @@protoc_insertion_point(field_get:subspace.GetTriggersResponse.retirement_fd_indexes) + return _internal_retirement_fd_indexes().Get(index); +} +inline void GetTriggersResponse::set_retirement_fd_indexes(int index, ::int32_t value) { + _internal_mutable_retirement_fd_indexes()->Set(index, value); + // @@protoc_insertion_point(field_set:subspace.GetTriggersResponse.retirement_fd_indexes) +} +inline void GetTriggersResponse::add_retirement_fd_indexes(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_retirement_fd_indexes()->Add(value); + // @@protoc_insertion_point(field_add:subspace.GetTriggersResponse.retirement_fd_indexes) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& GetTriggersResponse::retirement_fd_indexes() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.GetTriggersResponse.retirement_fd_indexes) + return _internal_retirement_fd_indexes(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* GetTriggersResponse::mutable_retirement_fd_indexes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.GetTriggersResponse.retirement_fd_indexes) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_retirement_fd_indexes(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +GetTriggersResponse::_internal_retirement_fd_indexes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.retirement_fd_indexes_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* GetTriggersResponse::_internal_mutable_retirement_fd_indexes() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.retirement_fd_indexes_; +} + +// ------------------------------------------------------------------- + +// RemovePublisherRequest + +// string channel_name = 1; +inline void RemovePublisherRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& RemovePublisherRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RemovePublisherRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RemovePublisherRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RemovePublisherRequest.channel_name) +} +inline std::string* RemovePublisherRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.RemovePublisherRequest.channel_name) + return _s; +} +inline const std::string& RemovePublisherRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void RemovePublisherRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* RemovePublisherRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* RemovePublisherRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RemovePublisherRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void RemovePublisherRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RemovePublisherRequest.channel_name) +} + +// int32 publisher_id = 2; +inline void RemovePublisherRequest::clear_publisher_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = 0; +} +inline ::int32_t RemovePublisherRequest::publisher_id() const { + // @@protoc_insertion_point(field_get:subspace.RemovePublisherRequest.publisher_id) + return _internal_publisher_id(); +} +inline void RemovePublisherRequest::set_publisher_id(::int32_t value) { + _internal_set_publisher_id(value); + // @@protoc_insertion_point(field_set:subspace.RemovePublisherRequest.publisher_id) +} +inline ::int32_t RemovePublisherRequest::_internal_publisher_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.publisher_id_; +} +inline void RemovePublisherRequest::_internal_set_publisher_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = value; +} + +// ------------------------------------------------------------------- + +// RemovePublisherResponse + +// string error = 1; +inline void RemovePublisherResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& RemovePublisherResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RemovePublisherResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RemovePublisherResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RemovePublisherResponse.error) +} +inline std::string* RemovePublisherResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.RemovePublisherResponse.error) + return _s; +} +inline const std::string& RemovePublisherResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void RemovePublisherResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* RemovePublisherResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* RemovePublisherResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RemovePublisherResponse.error) + return _impl_.error_.Release(); +} +inline void RemovePublisherResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RemovePublisherResponse.error) +} + +// ------------------------------------------------------------------- + +// RemoveSubscriberRequest + +// string channel_name = 1; +inline void RemoveSubscriberRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& RemoveSubscriberRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RemoveSubscriberRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RemoveSubscriberRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RemoveSubscriberRequest.channel_name) +} +inline std::string* RemoveSubscriberRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.RemoveSubscriberRequest.channel_name) + return _s; +} +inline const std::string& RemoveSubscriberRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void RemoveSubscriberRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* RemoveSubscriberRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* RemoveSubscriberRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RemoveSubscriberRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void RemoveSubscriberRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RemoveSubscriberRequest.channel_name) +} + +// int32 subscriber_id = 2; +inline void RemoveSubscriberRequest::clear_subscriber_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = 0; +} +inline ::int32_t RemoveSubscriberRequest::subscriber_id() const { + // @@protoc_insertion_point(field_get:subspace.RemoveSubscriberRequest.subscriber_id) + return _internal_subscriber_id(); +} +inline void RemoveSubscriberRequest::set_subscriber_id(::int32_t value) { + _internal_set_subscriber_id(value); + // @@protoc_insertion_point(field_set:subspace.RemoveSubscriberRequest.subscriber_id) +} +inline ::int32_t RemoveSubscriberRequest::_internal_subscriber_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.subscriber_id_; +} +inline void RemoveSubscriberRequest::_internal_set_subscriber_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = value; +} + +// ------------------------------------------------------------------- + +// RemoveSubscriberResponse + +// string error = 1; +inline void RemoveSubscriberResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& RemoveSubscriberResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RemoveSubscriberResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RemoveSubscriberResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RemoveSubscriberResponse.error) +} +inline std::string* RemoveSubscriberResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.RemoveSubscriberResponse.error) + return _s; +} +inline const std::string& RemoveSubscriberResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void RemoveSubscriberResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* RemoveSubscriberResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* RemoveSubscriberResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RemoveSubscriberResponse.error) + return _impl_.error_.Release(); +} +inline void RemoveSubscriberResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RemoveSubscriberResponse.error) +} + +// ------------------------------------------------------------------- + +// GetChannelInfoRequest + +// string channel_name = 1; +inline void GetChannelInfoRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& GetChannelInfoRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetChannelInfoRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GetChannelInfoRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.GetChannelInfoRequest.channel_name) +} +inline std::string* GetChannelInfoRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.GetChannelInfoRequest.channel_name) + return _s; +} +inline const std::string& GetChannelInfoRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void GetChannelInfoRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* GetChannelInfoRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* GetChannelInfoRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.GetChannelInfoRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void GetChannelInfoRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.GetChannelInfoRequest.channel_name) +} + +// ------------------------------------------------------------------- + +// GetChannelInfoResponse + +// string error = 1; +inline void GetChannelInfoResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& GetChannelInfoResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetChannelInfoResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GetChannelInfoResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.GetChannelInfoResponse.error) +} +inline std::string* GetChannelInfoResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.GetChannelInfoResponse.error) + return _s; +} +inline const std::string& GetChannelInfoResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void GetChannelInfoResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* GetChannelInfoResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* GetChannelInfoResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.GetChannelInfoResponse.error) + return _impl_.error_.Release(); +} +inline void GetChannelInfoResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.GetChannelInfoResponse.error) +} + +// repeated .subspace.ChannelInfoProto channels = 2; +inline int GetChannelInfoResponse::_internal_channels_size() const { + return _internal_channels().size(); +} +inline int GetChannelInfoResponse::channels_size() const { + return _internal_channels_size(); +} +inline void GetChannelInfoResponse::clear_channels() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channels_.Clear(); +} +inline ::subspace::ChannelInfoProto* GetChannelInfoResponse::mutable_channels(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:subspace.GetChannelInfoResponse.channels) + return _internal_mutable_channels()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* GetChannelInfoResponse::mutable_channels() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.GetChannelInfoResponse.channels) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_channels(); +} +inline const ::subspace::ChannelInfoProto& GetChannelInfoResponse::channels(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetChannelInfoResponse.channels) + return _internal_channels().Get(index); +} +inline ::subspace::ChannelInfoProto* GetChannelInfoResponse::add_channels() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::subspace::ChannelInfoProto* _add = _internal_mutable_channels()->Add(); + // @@protoc_insertion_point(field_add:subspace.GetChannelInfoResponse.channels) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& GetChannelInfoResponse::channels() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.GetChannelInfoResponse.channels) + return _internal_channels(); +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& +GetChannelInfoResponse::_internal_channels() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channels_; +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* +GetChannelInfoResponse::_internal_mutable_channels() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.channels_; +} + +// ------------------------------------------------------------------- + +// GetChannelStatsRequest + +// string channel_name = 1; +inline void GetChannelStatsRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& GetChannelStatsRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetChannelStatsRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GetChannelStatsRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.GetChannelStatsRequest.channel_name) +} +inline std::string* GetChannelStatsRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.GetChannelStatsRequest.channel_name) + return _s; +} +inline const std::string& GetChannelStatsRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void GetChannelStatsRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* GetChannelStatsRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* GetChannelStatsRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.GetChannelStatsRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void GetChannelStatsRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.GetChannelStatsRequest.channel_name) +} + +// ------------------------------------------------------------------- + +// GetChannelStatsResponse + +// string error = 1; +inline void GetChannelStatsResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& GetChannelStatsResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetChannelStatsResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GetChannelStatsResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.GetChannelStatsResponse.error) +} +inline std::string* GetChannelStatsResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.GetChannelStatsResponse.error) + return _s; +} +inline const std::string& GetChannelStatsResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void GetChannelStatsResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* GetChannelStatsResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* GetChannelStatsResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.GetChannelStatsResponse.error) + return _impl_.error_.Release(); +} +inline void GetChannelStatsResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.GetChannelStatsResponse.error) +} + +// repeated .subspace.ChannelStatsProto channels = 2; +inline int GetChannelStatsResponse::_internal_channels_size() const { + return _internal_channels().size(); +} +inline int GetChannelStatsResponse::channels_size() const { + return _internal_channels_size(); +} +inline void GetChannelStatsResponse::clear_channels() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channels_.Clear(); +} +inline ::subspace::ChannelStatsProto* GetChannelStatsResponse::mutable_channels(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:subspace.GetChannelStatsResponse.channels) + return _internal_mutable_channels()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* GetChannelStatsResponse::mutable_channels() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.GetChannelStatsResponse.channels) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_channels(); +} +inline const ::subspace::ChannelStatsProto& GetChannelStatsResponse::channels(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.GetChannelStatsResponse.channels) + return _internal_channels().Get(index); +} +inline ::subspace::ChannelStatsProto* GetChannelStatsResponse::add_channels() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::subspace::ChannelStatsProto* _add = _internal_mutable_channels()->Add(); + // @@protoc_insertion_point(field_add:subspace.GetChannelStatsResponse.channels) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& GetChannelStatsResponse::channels() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.GetChannelStatsResponse.channels) + return _internal_channels(); +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& +GetChannelStatsResponse::_internal_channels() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channels_; +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* +GetChannelStatsResponse::_internal_mutable_channels() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.channels_; +} + +// ------------------------------------------------------------------- + +// ClientBufferHandleMetadataProto + +// string channel_name = 1; +inline void ClientBufferHandleMetadataProto::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ClientBufferHandleMetadataProto::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientBufferHandleMetadataProto::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.channel_name) +} +inline std::string* ClientBufferHandleMetadataProto::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ClientBufferHandleMetadataProto.channel_name) + return _s; +} +inline const std::string& ClientBufferHandleMetadataProto::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ClientBufferHandleMetadataProto::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ClientBufferHandleMetadataProto.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ClientBufferHandleMetadataProto::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ClientBufferHandleMetadataProto.channel_name) +} + +// uint64 session_id = 2; +inline void ClientBufferHandleMetadataProto::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = ::uint64_t{0u}; +} +inline ::uint64_t ClientBufferHandleMetadataProto::session_id() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.session_id) + return _internal_session_id(); +} +inline void ClientBufferHandleMetadataProto::set_session_id(::uint64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.session_id) +} +inline ::uint64_t ClientBufferHandleMetadataProto::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_session_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// uint32 buffer_index = 3; +inline void ClientBufferHandleMetadataProto::clear_buffer_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.buffer_index_ = 0u; +} +inline ::uint32_t ClientBufferHandleMetadataProto::buffer_index() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.buffer_index) + return _internal_buffer_index(); +} +inline void ClientBufferHandleMetadataProto::set_buffer_index(::uint32_t value) { + _internal_set_buffer_index(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.buffer_index) +} +inline ::uint32_t ClientBufferHandleMetadataProto::_internal_buffer_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.buffer_index_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_buffer_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.buffer_index_ = value; +} + +// uint32 slot_id = 4; +inline void ClientBufferHandleMetadataProto::clear_slot_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_id_ = 0u; +} +inline ::uint32_t ClientBufferHandleMetadataProto::slot_id() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.slot_id) + return _internal_slot_id(); +} +inline void ClientBufferHandleMetadataProto::set_slot_id(::uint32_t value) { + _internal_set_slot_id(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.slot_id) +} +inline ::uint32_t ClientBufferHandleMetadataProto::_internal_slot_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_id_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_slot_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_id_ = value; +} + +// bool is_prefix = 5; +inline void ClientBufferHandleMetadataProto::clear_is_prefix() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_prefix_ = false; +} +inline bool ClientBufferHandleMetadataProto::is_prefix() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.is_prefix) + return _internal_is_prefix(); +} +inline void ClientBufferHandleMetadataProto::set_is_prefix(bool value) { + _internal_set_is_prefix(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.is_prefix) +} +inline bool ClientBufferHandleMetadataProto::_internal_is_prefix() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_prefix_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_is_prefix(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_prefix_ = value; +} + +// uint64 full_size = 6; +inline void ClientBufferHandleMetadataProto::clear_full_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.full_size_ = ::uint64_t{0u}; +} +inline ::uint64_t ClientBufferHandleMetadataProto::full_size() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.full_size) + return _internal_full_size(); +} +inline void ClientBufferHandleMetadataProto::set_full_size(::uint64_t value) { + _internal_set_full_size(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.full_size) +} +inline ::uint64_t ClientBufferHandleMetadataProto::_internal_full_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.full_size_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_full_size(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.full_size_ = value; +} + +// uint64 allocation_size = 7; +inline void ClientBufferHandleMetadataProto::clear_allocation_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.allocation_size_ = ::uint64_t{0u}; +} +inline ::uint64_t ClientBufferHandleMetadataProto::allocation_size() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.allocation_size) + return _internal_allocation_size(); +} +inline void ClientBufferHandleMetadataProto::set_allocation_size(::uint64_t value) { + _internal_set_allocation_size(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.allocation_size) +} +inline ::uint64_t ClientBufferHandleMetadataProto::_internal_allocation_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.allocation_size_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_allocation_size(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.allocation_size_ = value; +} + +// uint64 handle = 8; +inline void ClientBufferHandleMetadataProto::clear_handle() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.handle_ = ::uint64_t{0u}; +} +inline ::uint64_t ClientBufferHandleMetadataProto::handle() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.handle) + return _internal_handle(); +} +inline void ClientBufferHandleMetadataProto::set_handle(::uint64_t value) { + _internal_set_handle(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.handle) +} +inline ::uint64_t ClientBufferHandleMetadataProto::_internal_handle() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.handle_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_handle(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.handle_ = value; +} + +// string shadow_file = 9; +inline void ClientBufferHandleMetadataProto::clear_shadow_file() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.shadow_file_.ClearToEmpty(); +} +inline const std::string& ClientBufferHandleMetadataProto::shadow_file() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.shadow_file) + return _internal_shadow_file(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientBufferHandleMetadataProto::set_shadow_file(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.shadow_file_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.shadow_file) +} +inline std::string* ClientBufferHandleMetadataProto::mutable_shadow_file() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_shadow_file(); + // @@protoc_insertion_point(field_mutable:subspace.ClientBufferHandleMetadataProto.shadow_file) + return _s; +} +inline const std::string& ClientBufferHandleMetadataProto::_internal_shadow_file() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.shadow_file_.Get(); +} +inline void ClientBufferHandleMetadataProto::_internal_set_shadow_file(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.shadow_file_.Set(value, GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::_internal_mutable_shadow_file() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.shadow_file_.Mutable( GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::release_shadow_file() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ClientBufferHandleMetadataProto.shadow_file) + return _impl_.shadow_file_.Release(); +} +inline void ClientBufferHandleMetadataProto::set_allocated_shadow_file(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.shadow_file_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.shadow_file_.IsDefault()) { + _impl_.shadow_file_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ClientBufferHandleMetadataProto.shadow_file) +} + +// string object_name = 10; +inline void ClientBufferHandleMetadataProto::clear_object_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.object_name_.ClearToEmpty(); +} +inline const std::string& ClientBufferHandleMetadataProto::object_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.object_name) + return _internal_object_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientBufferHandleMetadataProto::set_object_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.object_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.object_name) +} +inline std::string* ClientBufferHandleMetadataProto::mutable_object_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_object_name(); + // @@protoc_insertion_point(field_mutable:subspace.ClientBufferHandleMetadataProto.object_name) + return _s; +} +inline const std::string& ClientBufferHandleMetadataProto::_internal_object_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.object_name_.Get(); +} +inline void ClientBufferHandleMetadataProto::_internal_set_object_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.object_name_.Set(value, GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::_internal_mutable_object_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.object_name_.Mutable( GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::release_object_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ClientBufferHandleMetadataProto.object_name) + return _impl_.object_name_.Release(); +} +inline void ClientBufferHandleMetadataProto::set_allocated_object_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.object_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.object_name_.IsDefault()) { + _impl_.object_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ClientBufferHandleMetadataProto.object_name) +} + +// string allocator = 11; +inline void ClientBufferHandleMetadataProto::clear_allocator() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.allocator_.ClearToEmpty(); +} +inline const std::string& ClientBufferHandleMetadataProto::allocator() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.allocator) + return _internal_allocator(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientBufferHandleMetadataProto::set_allocator(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.allocator_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.allocator) +} +inline std::string* ClientBufferHandleMetadataProto::mutable_allocator() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_allocator(); + // @@protoc_insertion_point(field_mutable:subspace.ClientBufferHandleMetadataProto.allocator) + return _s; +} +inline const std::string& ClientBufferHandleMetadataProto::_internal_allocator() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.allocator_.Get(); +} +inline void ClientBufferHandleMetadataProto::_internal_set_allocator(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.allocator_.Set(value, GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::_internal_mutable_allocator() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.allocator_.Mutable( GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::release_allocator() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ClientBufferHandleMetadataProto.allocator) + return _impl_.allocator_.Release(); +} +inline void ClientBufferHandleMetadataProto::set_allocated_allocator(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.allocator_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.allocator_.IsDefault()) { + _impl_.allocator_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ClientBufferHandleMetadataProto.allocator) +} + +// string pool_id = 12; +inline void ClientBufferHandleMetadataProto::clear_pool_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pool_id_.ClearToEmpty(); +} +inline const std::string& ClientBufferHandleMetadataProto::pool_id() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.pool_id) + return _internal_pool_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientBufferHandleMetadataProto::set_pool_id(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pool_id_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.pool_id) +} +inline std::string* ClientBufferHandleMetadataProto::mutable_pool_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_pool_id(); + // @@protoc_insertion_point(field_mutable:subspace.ClientBufferHandleMetadataProto.pool_id) + return _s; +} +inline const std::string& ClientBufferHandleMetadataProto::_internal_pool_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pool_id_.Get(); +} +inline void ClientBufferHandleMetadataProto::_internal_set_pool_id(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pool_id_.Set(value, GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::_internal_mutable_pool_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.pool_id_.Mutable( GetArena()); +} +inline std::string* ClientBufferHandleMetadataProto::release_pool_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ClientBufferHandleMetadataProto.pool_id) + return _impl_.pool_id_.Release(); +} +inline void ClientBufferHandleMetadataProto::set_allocated_pool_id(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pool_id_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.pool_id_.IsDefault()) { + _impl_.pool_id_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ClientBufferHandleMetadataProto.pool_id) +} + +// bool cache_enabled = 13; +inline void ClientBufferHandleMetadataProto::clear_cache_enabled() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cache_enabled_ = false; +} +inline bool ClientBufferHandleMetadataProto::cache_enabled() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.cache_enabled) + return _internal_cache_enabled(); +} +inline void ClientBufferHandleMetadataProto::set_cache_enabled(bool value) { + _internal_set_cache_enabled(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.cache_enabled) +} +inline bool ClientBufferHandleMetadataProto::_internal_cache_enabled() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.cache_enabled_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_cache_enabled(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cache_enabled_ = value; +} + +// uint32 alignment = 14; +inline void ClientBufferHandleMetadataProto::clear_alignment() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.alignment_ = 0u; +} +inline ::uint32_t ClientBufferHandleMetadataProto::alignment() const { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.alignment) + return _internal_alignment(); +} +inline void ClientBufferHandleMetadataProto::set_alignment(::uint32_t value) { + _internal_set_alignment(value); + // @@protoc_insertion_point(field_set:subspace.ClientBufferHandleMetadataProto.alignment) +} +inline ::uint32_t ClientBufferHandleMetadataProto::_internal_alignment() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.alignment_; +} +inline void ClientBufferHandleMetadataProto::_internal_set_alignment(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.alignment_ = value; +} + +// .google.protobuf.Any allocator_metadata = 15; +inline bool ClientBufferHandleMetadataProto::has_allocator_metadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.allocator_metadata_ != nullptr); + return value; +} +inline const ::google::protobuf::Any& ClientBufferHandleMetadataProto::_internal_allocator_metadata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::google::protobuf::Any* p = _impl_.allocator_metadata_; + return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); +} +inline const ::google::protobuf::Any& ClientBufferHandleMetadataProto::allocator_metadata() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ClientBufferHandleMetadataProto.allocator_metadata) + return _internal_allocator_metadata(); +} +inline void ClientBufferHandleMetadataProto::unsafe_arena_set_allocated_allocator_metadata(::google::protobuf::Any* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.allocator_metadata_); + } + _impl_.allocator_metadata_ = reinterpret_cast<::google::protobuf::Any*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ClientBufferHandleMetadataProto.allocator_metadata) +} +inline ::google::protobuf::Any* ClientBufferHandleMetadataProto::release_allocator_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* released = _impl_.allocator_metadata_; + _impl_.allocator_metadata_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::google::protobuf::Any* ClientBufferHandleMetadataProto::unsafe_arena_release_allocator_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ClientBufferHandleMetadataProto.allocator_metadata) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* temp = _impl_.allocator_metadata_; + _impl_.allocator_metadata_ = nullptr; + return temp; +} +inline ::google::protobuf::Any* ClientBufferHandleMetadataProto::_internal_mutable_allocator_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.allocator_metadata_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); + _impl_.allocator_metadata_ = reinterpret_cast<::google::protobuf::Any*>(p); + } + return _impl_.allocator_metadata_; +} +inline ::google::protobuf::Any* ClientBufferHandleMetadataProto::mutable_allocator_metadata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::google::protobuf::Any* _msg = _internal_mutable_allocator_metadata(); + // @@protoc_insertion_point(field_mutable:subspace.ClientBufferHandleMetadataProto.allocator_metadata) + return _msg; +} +inline void ClientBufferHandleMetadataProto::set_allocated_allocator_metadata(::google::protobuf::Any* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.allocator_metadata_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.allocator_metadata_ = reinterpret_cast<::google::protobuf::Any*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.ClientBufferHandleMetadataProto.allocator_metadata) +} + +// ------------------------------------------------------------------- + +// RegisterClientBufferRequest + +// .subspace.ClientBufferHandleMetadataProto metadata = 1; +inline bool RegisterClientBufferRequest::has_metadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.metadata_ != nullptr); + return value; +} +inline void RegisterClientBufferRequest::clear_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.metadata_ != nullptr) _impl_.metadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::subspace::ClientBufferHandleMetadataProto& RegisterClientBufferRequest::_internal_metadata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::subspace::ClientBufferHandleMetadataProto* p = _impl_.metadata_; + return p != nullptr ? *p : reinterpret_cast(::subspace::_ClientBufferHandleMetadataProto_default_instance_); +} +inline const ::subspace::ClientBufferHandleMetadataProto& RegisterClientBufferRequest::metadata() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RegisterClientBufferRequest.metadata) + return _internal_metadata(); +} +inline void RegisterClientBufferRequest::unsafe_arena_set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.metadata_); + } + _impl_.metadata_ = reinterpret_cast<::subspace::ClientBufferHandleMetadataProto*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RegisterClientBufferRequest.metadata) +} +inline ::subspace::ClientBufferHandleMetadataProto* RegisterClientBufferRequest::release_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ClientBufferHandleMetadataProto* released = _impl_.metadata_; + _impl_.metadata_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::subspace::ClientBufferHandleMetadataProto* RegisterClientBufferRequest::unsafe_arena_release_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RegisterClientBufferRequest.metadata) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ClientBufferHandleMetadataProto* temp = _impl_.metadata_; + _impl_.metadata_ = nullptr; + return temp; +} +inline ::subspace::ClientBufferHandleMetadataProto* RegisterClientBufferRequest::_internal_mutable_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.metadata_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::subspace::ClientBufferHandleMetadataProto>(GetArena()); + _impl_.metadata_ = reinterpret_cast<::subspace::ClientBufferHandleMetadataProto*>(p); + } + return _impl_.metadata_; +} +inline ::subspace::ClientBufferHandleMetadataProto* RegisterClientBufferRequest::mutable_metadata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::subspace::ClientBufferHandleMetadataProto* _msg = _internal_mutable_metadata(); + // @@protoc_insertion_point(field_mutable:subspace.RegisterClientBufferRequest.metadata) + return _msg; +} +inline void RegisterClientBufferRequest::set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.metadata_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.metadata_ = reinterpret_cast<::subspace::ClientBufferHandleMetadataProto*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.RegisterClientBufferRequest.metadata) +} + +// ------------------------------------------------------------------- + +// UnregisterClientBufferRequest + +// string channel_name = 1; +inline void UnregisterClientBufferRequest::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& UnregisterClientBufferRequest::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.UnregisterClientBufferRequest.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void UnregisterClientBufferRequest::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.UnregisterClientBufferRequest.channel_name) +} +inline std::string* UnregisterClientBufferRequest::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.UnregisterClientBufferRequest.channel_name) + return _s; +} +inline const std::string& UnregisterClientBufferRequest::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void UnregisterClientBufferRequest::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* UnregisterClientBufferRequest::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* UnregisterClientBufferRequest::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.UnregisterClientBufferRequest.channel_name) + return _impl_.channel_name_.Release(); +} +inline void UnregisterClientBufferRequest::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.UnregisterClientBufferRequest.channel_name) +} + +// uint64 session_id = 2; +inline void UnregisterClientBufferRequest::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = ::uint64_t{0u}; +} +inline ::uint64_t UnregisterClientBufferRequest::session_id() const { + // @@protoc_insertion_point(field_get:subspace.UnregisterClientBufferRequest.session_id) + return _internal_session_id(); +} +inline void UnregisterClientBufferRequest::set_session_id(::uint64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.UnregisterClientBufferRequest.session_id) +} +inline ::uint64_t UnregisterClientBufferRequest::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void UnregisterClientBufferRequest::_internal_set_session_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// uint32 buffer_index = 3; +inline void UnregisterClientBufferRequest::clear_buffer_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.buffer_index_ = 0u; +} +inline ::uint32_t UnregisterClientBufferRequest::buffer_index() const { + // @@protoc_insertion_point(field_get:subspace.UnregisterClientBufferRequest.buffer_index) + return _internal_buffer_index(); +} +inline void UnregisterClientBufferRequest::set_buffer_index(::uint32_t value) { + _internal_set_buffer_index(value); + // @@protoc_insertion_point(field_set:subspace.UnregisterClientBufferRequest.buffer_index) +} +inline ::uint32_t UnregisterClientBufferRequest::_internal_buffer_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.buffer_index_; +} +inline void UnregisterClientBufferRequest::_internal_set_buffer_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.buffer_index_ = value; +} + +// ------------------------------------------------------------------- + +// Request + +// .subspace.InitRequest init = 1; +inline bool Request::has_init() const { + return request_case() == kInit; +} +inline bool Request::_internal_has_init() const { + return request_case() == kInit; +} +inline void Request::set_has_init() { + _impl_._oneof_case_[0] = kInit; +} +inline void Request::clear_init() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kInit) { + if (GetArena() == nullptr) { + delete _impl_.request_.init_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.init_); + } + clear_has_request(); + } +} +inline ::subspace::InitRequest* Request::release_init() { + // @@protoc_insertion_point(field_release:subspace.Request.init) + if (request_case() == kInit) { + clear_has_request(); + auto* temp = _impl_.request_.init_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.init_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::InitRequest& Request::_internal_init() const { + return request_case() == kInit ? *_impl_.request_.init_ : reinterpret_cast<::subspace::InitRequest&>(::subspace::_InitRequest_default_instance_); +} +inline const ::subspace::InitRequest& Request::init() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.init) + return _internal_init(); +} +inline ::subspace::InitRequest* Request::unsafe_arena_release_init() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.init) + if (request_case() == kInit) { + clear_has_request(); + auto* temp = _impl_.request_.init_; + _impl_.request_.init_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_init(::subspace::InitRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_init(); + _impl_.request_.init_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.init) +} +inline ::subspace::InitRequest* Request::_internal_mutable_init() { + if (request_case() != kInit) { + clear_request(); + set_has_init(); + _impl_.request_.init_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::InitRequest>(GetArena()); + } + return _impl_.request_.init_; +} +inline ::subspace::InitRequest* Request::mutable_init() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::InitRequest* _msg = _internal_mutable_init(); + // @@protoc_insertion_point(field_mutable:subspace.Request.init) + return _msg; +} + +// .subspace.CreatePublisherRequest create_publisher = 2; +inline bool Request::has_create_publisher() const { + return request_case() == kCreatePublisher; +} +inline bool Request::_internal_has_create_publisher() const { + return request_case() == kCreatePublisher; +} +inline void Request::set_has_create_publisher() { + _impl_._oneof_case_[0] = kCreatePublisher; +} +inline void Request::clear_create_publisher() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kCreatePublisher) { + if (GetArena() == nullptr) { + delete _impl_.request_.create_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.create_publisher_); + } + clear_has_request(); + } +} +inline ::subspace::CreatePublisherRequest* Request::release_create_publisher() { + // @@protoc_insertion_point(field_release:subspace.Request.create_publisher) + if (request_case() == kCreatePublisher) { + clear_has_request(); + auto* temp = _impl_.request_.create_publisher_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.create_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::CreatePublisherRequest& Request::_internal_create_publisher() const { + return request_case() == kCreatePublisher ? *_impl_.request_.create_publisher_ : reinterpret_cast<::subspace::CreatePublisherRequest&>(::subspace::_CreatePublisherRequest_default_instance_); +} +inline const ::subspace::CreatePublisherRequest& Request::create_publisher() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.create_publisher) + return _internal_create_publisher(); +} +inline ::subspace::CreatePublisherRequest* Request::unsafe_arena_release_create_publisher() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.create_publisher) + if (request_case() == kCreatePublisher) { + clear_has_request(); + auto* temp = _impl_.request_.create_publisher_; + _impl_.request_.create_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_create_publisher(::subspace::CreatePublisherRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_create_publisher(); + _impl_.request_.create_publisher_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.create_publisher) +} +inline ::subspace::CreatePublisherRequest* Request::_internal_mutable_create_publisher() { + if (request_case() != kCreatePublisher) { + clear_request(); + set_has_create_publisher(); + _impl_.request_.create_publisher_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::CreatePublisherRequest>(GetArena()); + } + return _impl_.request_.create_publisher_; +} +inline ::subspace::CreatePublisherRequest* Request::mutable_create_publisher() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::CreatePublisherRequest* _msg = _internal_mutable_create_publisher(); + // @@protoc_insertion_point(field_mutable:subspace.Request.create_publisher) + return _msg; +} + +// .subspace.CreateSubscriberRequest create_subscriber = 3; +inline bool Request::has_create_subscriber() const { + return request_case() == kCreateSubscriber; +} +inline bool Request::_internal_has_create_subscriber() const { + return request_case() == kCreateSubscriber; +} +inline void Request::set_has_create_subscriber() { + _impl_._oneof_case_[0] = kCreateSubscriber; +} +inline void Request::clear_create_subscriber() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kCreateSubscriber) { + if (GetArena() == nullptr) { + delete _impl_.request_.create_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.create_subscriber_); + } + clear_has_request(); + } +} +inline ::subspace::CreateSubscriberRequest* Request::release_create_subscriber() { + // @@protoc_insertion_point(field_release:subspace.Request.create_subscriber) + if (request_case() == kCreateSubscriber) { + clear_has_request(); + auto* temp = _impl_.request_.create_subscriber_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.create_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::CreateSubscriberRequest& Request::_internal_create_subscriber() const { + return request_case() == kCreateSubscriber ? *_impl_.request_.create_subscriber_ : reinterpret_cast<::subspace::CreateSubscriberRequest&>(::subspace::_CreateSubscriberRequest_default_instance_); +} +inline const ::subspace::CreateSubscriberRequest& Request::create_subscriber() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.create_subscriber) + return _internal_create_subscriber(); +} +inline ::subspace::CreateSubscriberRequest* Request::unsafe_arena_release_create_subscriber() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.create_subscriber) + if (request_case() == kCreateSubscriber) { + clear_has_request(); + auto* temp = _impl_.request_.create_subscriber_; + _impl_.request_.create_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_create_subscriber(::subspace::CreateSubscriberRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_create_subscriber(); + _impl_.request_.create_subscriber_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.create_subscriber) +} +inline ::subspace::CreateSubscriberRequest* Request::_internal_mutable_create_subscriber() { + if (request_case() != kCreateSubscriber) { + clear_request(); + set_has_create_subscriber(); + _impl_.request_.create_subscriber_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::CreateSubscriberRequest>(GetArena()); + } + return _impl_.request_.create_subscriber_; +} +inline ::subspace::CreateSubscriberRequest* Request::mutable_create_subscriber() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::CreateSubscriberRequest* _msg = _internal_mutable_create_subscriber(); + // @@protoc_insertion_point(field_mutable:subspace.Request.create_subscriber) + return _msg; +} + +// .subspace.GetTriggersRequest get_triggers = 4; +inline bool Request::has_get_triggers() const { + return request_case() == kGetTriggers; +} +inline bool Request::_internal_has_get_triggers() const { + return request_case() == kGetTriggers; +} +inline void Request::set_has_get_triggers() { + _impl_._oneof_case_[0] = kGetTriggers; +} +inline void Request::clear_get_triggers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kGetTriggers) { + if (GetArena() == nullptr) { + delete _impl_.request_.get_triggers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.get_triggers_); + } + clear_has_request(); + } +} +inline ::subspace::GetTriggersRequest* Request::release_get_triggers() { + // @@protoc_insertion_point(field_release:subspace.Request.get_triggers) + if (request_case() == kGetTriggers) { + clear_has_request(); + auto* temp = _impl_.request_.get_triggers_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.get_triggers_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::GetTriggersRequest& Request::_internal_get_triggers() const { + return request_case() == kGetTriggers ? *_impl_.request_.get_triggers_ : reinterpret_cast<::subspace::GetTriggersRequest&>(::subspace::_GetTriggersRequest_default_instance_); +} +inline const ::subspace::GetTriggersRequest& Request::get_triggers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.get_triggers) + return _internal_get_triggers(); +} +inline ::subspace::GetTriggersRequest* Request::unsafe_arena_release_get_triggers() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.get_triggers) + if (request_case() == kGetTriggers) { + clear_has_request(); + auto* temp = _impl_.request_.get_triggers_; + _impl_.request_.get_triggers_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_get_triggers(::subspace::GetTriggersRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_get_triggers(); + _impl_.request_.get_triggers_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.get_triggers) +} +inline ::subspace::GetTriggersRequest* Request::_internal_mutable_get_triggers() { + if (request_case() != kGetTriggers) { + clear_request(); + set_has_get_triggers(); + _impl_.request_.get_triggers_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::GetTriggersRequest>(GetArena()); + } + return _impl_.request_.get_triggers_; +} +inline ::subspace::GetTriggersRequest* Request::mutable_get_triggers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::GetTriggersRequest* _msg = _internal_mutable_get_triggers(); + // @@protoc_insertion_point(field_mutable:subspace.Request.get_triggers) + return _msg; +} + +// .subspace.RemovePublisherRequest remove_publisher = 5; +inline bool Request::has_remove_publisher() const { + return request_case() == kRemovePublisher; +} +inline bool Request::_internal_has_remove_publisher() const { + return request_case() == kRemovePublisher; +} +inline void Request::set_has_remove_publisher() { + _impl_._oneof_case_[0] = kRemovePublisher; +} +inline void Request::clear_remove_publisher() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kRemovePublisher) { + if (GetArena() == nullptr) { + delete _impl_.request_.remove_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.remove_publisher_); + } + clear_has_request(); + } +} +inline ::subspace::RemovePublisherRequest* Request::release_remove_publisher() { + // @@protoc_insertion_point(field_release:subspace.Request.remove_publisher) + if (request_case() == kRemovePublisher) { + clear_has_request(); + auto* temp = _impl_.request_.remove_publisher_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.remove_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RemovePublisherRequest& Request::_internal_remove_publisher() const { + return request_case() == kRemovePublisher ? *_impl_.request_.remove_publisher_ : reinterpret_cast<::subspace::RemovePublisherRequest&>(::subspace::_RemovePublisherRequest_default_instance_); +} +inline const ::subspace::RemovePublisherRequest& Request::remove_publisher() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.remove_publisher) + return _internal_remove_publisher(); +} +inline ::subspace::RemovePublisherRequest* Request::unsafe_arena_release_remove_publisher() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.remove_publisher) + if (request_case() == kRemovePublisher) { + clear_has_request(); + auto* temp = _impl_.request_.remove_publisher_; + _impl_.request_.remove_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_remove_publisher(::subspace::RemovePublisherRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_remove_publisher(); + _impl_.request_.remove_publisher_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.remove_publisher) +} +inline ::subspace::RemovePublisherRequest* Request::_internal_mutable_remove_publisher() { + if (request_case() != kRemovePublisher) { + clear_request(); + set_has_remove_publisher(); + _impl_.request_.remove_publisher_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RemovePublisherRequest>(GetArena()); + } + return _impl_.request_.remove_publisher_; +} +inline ::subspace::RemovePublisherRequest* Request::mutable_remove_publisher() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RemovePublisherRequest* _msg = _internal_mutable_remove_publisher(); + // @@protoc_insertion_point(field_mutable:subspace.Request.remove_publisher) + return _msg; +} + +// .subspace.RemoveSubscriberRequest remove_subscriber = 6; +inline bool Request::has_remove_subscriber() const { + return request_case() == kRemoveSubscriber; +} +inline bool Request::_internal_has_remove_subscriber() const { + return request_case() == kRemoveSubscriber; +} +inline void Request::set_has_remove_subscriber() { + _impl_._oneof_case_[0] = kRemoveSubscriber; +} +inline void Request::clear_remove_subscriber() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kRemoveSubscriber) { + if (GetArena() == nullptr) { + delete _impl_.request_.remove_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.remove_subscriber_); + } + clear_has_request(); + } +} +inline ::subspace::RemoveSubscriberRequest* Request::release_remove_subscriber() { + // @@protoc_insertion_point(field_release:subspace.Request.remove_subscriber) + if (request_case() == kRemoveSubscriber) { + clear_has_request(); + auto* temp = _impl_.request_.remove_subscriber_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.remove_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RemoveSubscriberRequest& Request::_internal_remove_subscriber() const { + return request_case() == kRemoveSubscriber ? *_impl_.request_.remove_subscriber_ : reinterpret_cast<::subspace::RemoveSubscriberRequest&>(::subspace::_RemoveSubscriberRequest_default_instance_); +} +inline const ::subspace::RemoveSubscriberRequest& Request::remove_subscriber() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.remove_subscriber) + return _internal_remove_subscriber(); +} +inline ::subspace::RemoveSubscriberRequest* Request::unsafe_arena_release_remove_subscriber() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.remove_subscriber) + if (request_case() == kRemoveSubscriber) { + clear_has_request(); + auto* temp = _impl_.request_.remove_subscriber_; + _impl_.request_.remove_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_remove_subscriber(::subspace::RemoveSubscriberRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_remove_subscriber(); + _impl_.request_.remove_subscriber_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.remove_subscriber) +} +inline ::subspace::RemoveSubscriberRequest* Request::_internal_mutable_remove_subscriber() { + if (request_case() != kRemoveSubscriber) { + clear_request(); + set_has_remove_subscriber(); + _impl_.request_.remove_subscriber_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RemoveSubscriberRequest>(GetArena()); + } + return _impl_.request_.remove_subscriber_; +} +inline ::subspace::RemoveSubscriberRequest* Request::mutable_remove_subscriber() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RemoveSubscriberRequest* _msg = _internal_mutable_remove_subscriber(); + // @@protoc_insertion_point(field_mutable:subspace.Request.remove_subscriber) + return _msg; +} + +// .subspace.GetChannelInfoRequest get_channel_info = 9; +inline bool Request::has_get_channel_info() const { + return request_case() == kGetChannelInfo; +} +inline bool Request::_internal_has_get_channel_info() const { + return request_case() == kGetChannelInfo; +} +inline void Request::set_has_get_channel_info() { + _impl_._oneof_case_[0] = kGetChannelInfo; +} +inline void Request::clear_get_channel_info() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kGetChannelInfo) { + if (GetArena() == nullptr) { + delete _impl_.request_.get_channel_info_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.get_channel_info_); + } + clear_has_request(); + } +} +inline ::subspace::GetChannelInfoRequest* Request::release_get_channel_info() { + // @@protoc_insertion_point(field_release:subspace.Request.get_channel_info) + if (request_case() == kGetChannelInfo) { + clear_has_request(); + auto* temp = _impl_.request_.get_channel_info_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.get_channel_info_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::GetChannelInfoRequest& Request::_internal_get_channel_info() const { + return request_case() == kGetChannelInfo ? *_impl_.request_.get_channel_info_ : reinterpret_cast<::subspace::GetChannelInfoRequest&>(::subspace::_GetChannelInfoRequest_default_instance_); +} +inline const ::subspace::GetChannelInfoRequest& Request::get_channel_info() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.get_channel_info) + return _internal_get_channel_info(); +} +inline ::subspace::GetChannelInfoRequest* Request::unsafe_arena_release_get_channel_info() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.get_channel_info) + if (request_case() == kGetChannelInfo) { + clear_has_request(); + auto* temp = _impl_.request_.get_channel_info_; + _impl_.request_.get_channel_info_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_get_channel_info(::subspace::GetChannelInfoRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_get_channel_info(); + _impl_.request_.get_channel_info_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.get_channel_info) +} +inline ::subspace::GetChannelInfoRequest* Request::_internal_mutable_get_channel_info() { + if (request_case() != kGetChannelInfo) { + clear_request(); + set_has_get_channel_info(); + _impl_.request_.get_channel_info_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::GetChannelInfoRequest>(GetArena()); + } + return _impl_.request_.get_channel_info_; +} +inline ::subspace::GetChannelInfoRequest* Request::mutable_get_channel_info() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::GetChannelInfoRequest* _msg = _internal_mutable_get_channel_info(); + // @@protoc_insertion_point(field_mutable:subspace.Request.get_channel_info) + return _msg; +} + +// .subspace.GetChannelStatsRequest get_channel_stats = 10; +inline bool Request::has_get_channel_stats() const { + return request_case() == kGetChannelStats; +} +inline bool Request::_internal_has_get_channel_stats() const { + return request_case() == kGetChannelStats; +} +inline void Request::set_has_get_channel_stats() { + _impl_._oneof_case_[0] = kGetChannelStats; +} +inline void Request::clear_get_channel_stats() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kGetChannelStats) { + if (GetArena() == nullptr) { + delete _impl_.request_.get_channel_stats_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.get_channel_stats_); + } + clear_has_request(); + } +} +inline ::subspace::GetChannelStatsRequest* Request::release_get_channel_stats() { + // @@protoc_insertion_point(field_release:subspace.Request.get_channel_stats) + if (request_case() == kGetChannelStats) { + clear_has_request(); + auto* temp = _impl_.request_.get_channel_stats_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.get_channel_stats_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::GetChannelStatsRequest& Request::_internal_get_channel_stats() const { + return request_case() == kGetChannelStats ? *_impl_.request_.get_channel_stats_ : reinterpret_cast<::subspace::GetChannelStatsRequest&>(::subspace::_GetChannelStatsRequest_default_instance_); +} +inline const ::subspace::GetChannelStatsRequest& Request::get_channel_stats() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.get_channel_stats) + return _internal_get_channel_stats(); +} +inline ::subspace::GetChannelStatsRequest* Request::unsafe_arena_release_get_channel_stats() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.get_channel_stats) + if (request_case() == kGetChannelStats) { + clear_has_request(); + auto* temp = _impl_.request_.get_channel_stats_; + _impl_.request_.get_channel_stats_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_get_channel_stats(::subspace::GetChannelStatsRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_get_channel_stats(); + _impl_.request_.get_channel_stats_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.get_channel_stats) +} +inline ::subspace::GetChannelStatsRequest* Request::_internal_mutable_get_channel_stats() { + if (request_case() != kGetChannelStats) { + clear_request(); + set_has_get_channel_stats(); + _impl_.request_.get_channel_stats_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::GetChannelStatsRequest>(GetArena()); + } + return _impl_.request_.get_channel_stats_; +} +inline ::subspace::GetChannelStatsRequest* Request::mutable_get_channel_stats() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::GetChannelStatsRequest* _msg = _internal_mutable_get_channel_stats(); + // @@protoc_insertion_point(field_mutable:subspace.Request.get_channel_stats) + return _msg; +} + +// .subspace.RegisterClientBufferRequest register_client_buffer = 11; +inline bool Request::has_register_client_buffer() const { + return request_case() == kRegisterClientBuffer; +} +inline bool Request::_internal_has_register_client_buffer() const { + return request_case() == kRegisterClientBuffer; +} +inline void Request::set_has_register_client_buffer() { + _impl_._oneof_case_[0] = kRegisterClientBuffer; +} +inline void Request::clear_register_client_buffer() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kRegisterClientBuffer) { + if (GetArena() == nullptr) { + delete _impl_.request_.register_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.register_client_buffer_); + } + clear_has_request(); + } +} +inline ::subspace::RegisterClientBufferRequest* Request::release_register_client_buffer() { + // @@protoc_insertion_point(field_release:subspace.Request.register_client_buffer) + if (request_case() == kRegisterClientBuffer) { + clear_has_request(); + auto* temp = _impl_.request_.register_client_buffer_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.register_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RegisterClientBufferRequest& Request::_internal_register_client_buffer() const { + return request_case() == kRegisterClientBuffer ? *_impl_.request_.register_client_buffer_ : reinterpret_cast<::subspace::RegisterClientBufferRequest&>(::subspace::_RegisterClientBufferRequest_default_instance_); +} +inline const ::subspace::RegisterClientBufferRequest& Request::register_client_buffer() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.register_client_buffer) + return _internal_register_client_buffer(); +} +inline ::subspace::RegisterClientBufferRequest* Request::unsafe_arena_release_register_client_buffer() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.register_client_buffer) + if (request_case() == kRegisterClientBuffer) { + clear_has_request(); + auto* temp = _impl_.request_.register_client_buffer_; + _impl_.request_.register_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_register_client_buffer(::subspace::RegisterClientBufferRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_register_client_buffer(); + _impl_.request_.register_client_buffer_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.register_client_buffer) +} +inline ::subspace::RegisterClientBufferRequest* Request::_internal_mutable_register_client_buffer() { + if (request_case() != kRegisterClientBuffer) { + clear_request(); + set_has_register_client_buffer(); + _impl_.request_.register_client_buffer_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RegisterClientBufferRequest>(GetArena()); + } + return _impl_.request_.register_client_buffer_; +} +inline ::subspace::RegisterClientBufferRequest* Request::mutable_register_client_buffer() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RegisterClientBufferRequest* _msg = _internal_mutable_register_client_buffer(); + // @@protoc_insertion_point(field_mutable:subspace.Request.register_client_buffer) + return _msg; +} + +// .subspace.UnregisterClientBufferRequest unregister_client_buffer = 12; +inline bool Request::has_unregister_client_buffer() const { + return request_case() == kUnregisterClientBuffer; +} +inline bool Request::_internal_has_unregister_client_buffer() const { + return request_case() == kUnregisterClientBuffer; +} +inline void Request::set_has_unregister_client_buffer() { + _impl_._oneof_case_[0] = kUnregisterClientBuffer; +} +inline void Request::clear_unregister_client_buffer() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kUnregisterClientBuffer) { + if (GetArena() == nullptr) { + delete _impl_.request_.unregister_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.unregister_client_buffer_); + } + clear_has_request(); + } +} +inline ::subspace::UnregisterClientBufferRequest* Request::release_unregister_client_buffer() { + // @@protoc_insertion_point(field_release:subspace.Request.unregister_client_buffer) + if (request_case() == kUnregisterClientBuffer) { + clear_has_request(); + auto* temp = _impl_.request_.unregister_client_buffer_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.unregister_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::UnregisterClientBufferRequest& Request::_internal_unregister_client_buffer() const { + return request_case() == kUnregisterClientBuffer ? *_impl_.request_.unregister_client_buffer_ : reinterpret_cast<::subspace::UnregisterClientBufferRequest&>(::subspace::_UnregisterClientBufferRequest_default_instance_); +} +inline const ::subspace::UnregisterClientBufferRequest& Request::unregister_client_buffer() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Request.unregister_client_buffer) + return _internal_unregister_client_buffer(); +} +inline ::subspace::UnregisterClientBufferRequest* Request::unsafe_arena_release_unregister_client_buffer() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Request.unregister_client_buffer) + if (request_case() == kUnregisterClientBuffer) { + clear_has_request(); + auto* temp = _impl_.request_.unregister_client_buffer_; + _impl_.request_.unregister_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Request::unsafe_arena_set_allocated_unregister_client_buffer(::subspace::UnregisterClientBufferRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_unregister_client_buffer(); + _impl_.request_.unregister_client_buffer_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Request.unregister_client_buffer) +} +inline ::subspace::UnregisterClientBufferRequest* Request::_internal_mutable_unregister_client_buffer() { + if (request_case() != kUnregisterClientBuffer) { + clear_request(); + set_has_unregister_client_buffer(); + _impl_.request_.unregister_client_buffer_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::UnregisterClientBufferRequest>(GetArena()); + } + return _impl_.request_.unregister_client_buffer_; +} +inline ::subspace::UnregisterClientBufferRequest* Request::mutable_unregister_client_buffer() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::UnregisterClientBufferRequest* _msg = _internal_mutable_unregister_client_buffer(); + // @@protoc_insertion_point(field_mutable:subspace.Request.unregister_client_buffer) + return _msg; +} + +inline bool Request::has_request() const { + return request_case() != REQUEST_NOT_SET; +} +inline void Request::clear_has_request() { + _impl_._oneof_case_[0] = REQUEST_NOT_SET; +} +inline Request::RequestCase Request::request_case() const { + return Request::RequestCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Response + +// .subspace.InitResponse init = 1; +inline bool Response::has_init() const { + return response_case() == kInit; +} +inline bool Response::_internal_has_init() const { + return response_case() == kInit; +} +inline void Response::set_has_init() { + _impl_._oneof_case_[0] = kInit; +} +inline void Response::clear_init() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kInit) { + if (GetArena() == nullptr) { + delete _impl_.response_.init_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.init_); + } + clear_has_response(); + } +} +inline ::subspace::InitResponse* Response::release_init() { + // @@protoc_insertion_point(field_release:subspace.Response.init) + if (response_case() == kInit) { + clear_has_response(); + auto* temp = _impl_.response_.init_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.init_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::InitResponse& Response::_internal_init() const { + return response_case() == kInit ? *_impl_.response_.init_ : reinterpret_cast<::subspace::InitResponse&>(::subspace::_InitResponse_default_instance_); +} +inline const ::subspace::InitResponse& Response::init() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.init) + return _internal_init(); +} +inline ::subspace::InitResponse* Response::unsafe_arena_release_init() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.init) + if (response_case() == kInit) { + clear_has_response(); + auto* temp = _impl_.response_.init_; + _impl_.response_.init_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_init(::subspace::InitResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_init(); + _impl_.response_.init_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.init) +} +inline ::subspace::InitResponse* Response::_internal_mutable_init() { + if (response_case() != kInit) { + clear_response(); + set_has_init(); + _impl_.response_.init_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::InitResponse>(GetArena()); + } + return _impl_.response_.init_; +} +inline ::subspace::InitResponse* Response::mutable_init() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::InitResponse* _msg = _internal_mutable_init(); + // @@protoc_insertion_point(field_mutable:subspace.Response.init) + return _msg; +} + +// .subspace.CreatePublisherResponse create_publisher = 2; +inline bool Response::has_create_publisher() const { + return response_case() == kCreatePublisher; +} +inline bool Response::_internal_has_create_publisher() const { + return response_case() == kCreatePublisher; +} +inline void Response::set_has_create_publisher() { + _impl_._oneof_case_[0] = kCreatePublisher; +} +inline void Response::clear_create_publisher() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kCreatePublisher) { + if (GetArena() == nullptr) { + delete _impl_.response_.create_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.create_publisher_); + } + clear_has_response(); + } +} +inline ::subspace::CreatePublisherResponse* Response::release_create_publisher() { + // @@protoc_insertion_point(field_release:subspace.Response.create_publisher) + if (response_case() == kCreatePublisher) { + clear_has_response(); + auto* temp = _impl_.response_.create_publisher_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.create_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::CreatePublisherResponse& Response::_internal_create_publisher() const { + return response_case() == kCreatePublisher ? *_impl_.response_.create_publisher_ : reinterpret_cast<::subspace::CreatePublisherResponse&>(::subspace::_CreatePublisherResponse_default_instance_); +} +inline const ::subspace::CreatePublisherResponse& Response::create_publisher() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.create_publisher) + return _internal_create_publisher(); +} +inline ::subspace::CreatePublisherResponse* Response::unsafe_arena_release_create_publisher() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.create_publisher) + if (response_case() == kCreatePublisher) { + clear_has_response(); + auto* temp = _impl_.response_.create_publisher_; + _impl_.response_.create_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_create_publisher(::subspace::CreatePublisherResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_create_publisher(); + _impl_.response_.create_publisher_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.create_publisher) +} +inline ::subspace::CreatePublisherResponse* Response::_internal_mutable_create_publisher() { + if (response_case() != kCreatePublisher) { + clear_response(); + set_has_create_publisher(); + _impl_.response_.create_publisher_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::CreatePublisherResponse>(GetArena()); + } + return _impl_.response_.create_publisher_; +} +inline ::subspace::CreatePublisherResponse* Response::mutable_create_publisher() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::CreatePublisherResponse* _msg = _internal_mutable_create_publisher(); + // @@protoc_insertion_point(field_mutable:subspace.Response.create_publisher) + return _msg; +} + +// .subspace.CreateSubscriberResponse create_subscriber = 3; +inline bool Response::has_create_subscriber() const { + return response_case() == kCreateSubscriber; +} +inline bool Response::_internal_has_create_subscriber() const { + return response_case() == kCreateSubscriber; +} +inline void Response::set_has_create_subscriber() { + _impl_._oneof_case_[0] = kCreateSubscriber; +} +inline void Response::clear_create_subscriber() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kCreateSubscriber) { + if (GetArena() == nullptr) { + delete _impl_.response_.create_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.create_subscriber_); + } + clear_has_response(); + } +} +inline ::subspace::CreateSubscriberResponse* Response::release_create_subscriber() { + // @@protoc_insertion_point(field_release:subspace.Response.create_subscriber) + if (response_case() == kCreateSubscriber) { + clear_has_response(); + auto* temp = _impl_.response_.create_subscriber_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.create_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::CreateSubscriberResponse& Response::_internal_create_subscriber() const { + return response_case() == kCreateSubscriber ? *_impl_.response_.create_subscriber_ : reinterpret_cast<::subspace::CreateSubscriberResponse&>(::subspace::_CreateSubscriberResponse_default_instance_); +} +inline const ::subspace::CreateSubscriberResponse& Response::create_subscriber() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.create_subscriber) + return _internal_create_subscriber(); +} +inline ::subspace::CreateSubscriberResponse* Response::unsafe_arena_release_create_subscriber() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.create_subscriber) + if (response_case() == kCreateSubscriber) { + clear_has_response(); + auto* temp = _impl_.response_.create_subscriber_; + _impl_.response_.create_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_create_subscriber(::subspace::CreateSubscriberResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_create_subscriber(); + _impl_.response_.create_subscriber_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.create_subscriber) +} +inline ::subspace::CreateSubscriberResponse* Response::_internal_mutable_create_subscriber() { + if (response_case() != kCreateSubscriber) { + clear_response(); + set_has_create_subscriber(); + _impl_.response_.create_subscriber_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::CreateSubscriberResponse>(GetArena()); + } + return _impl_.response_.create_subscriber_; +} +inline ::subspace::CreateSubscriberResponse* Response::mutable_create_subscriber() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::CreateSubscriberResponse* _msg = _internal_mutable_create_subscriber(); + // @@protoc_insertion_point(field_mutable:subspace.Response.create_subscriber) + return _msg; +} + +// .subspace.GetTriggersResponse get_triggers = 4; +inline bool Response::has_get_triggers() const { + return response_case() == kGetTriggers; +} +inline bool Response::_internal_has_get_triggers() const { + return response_case() == kGetTriggers; +} +inline void Response::set_has_get_triggers() { + _impl_._oneof_case_[0] = kGetTriggers; +} +inline void Response::clear_get_triggers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kGetTriggers) { + if (GetArena() == nullptr) { + delete _impl_.response_.get_triggers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.get_triggers_); + } + clear_has_response(); + } +} +inline ::subspace::GetTriggersResponse* Response::release_get_triggers() { + // @@protoc_insertion_point(field_release:subspace.Response.get_triggers) + if (response_case() == kGetTriggers) { + clear_has_response(); + auto* temp = _impl_.response_.get_triggers_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.get_triggers_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::GetTriggersResponse& Response::_internal_get_triggers() const { + return response_case() == kGetTriggers ? *_impl_.response_.get_triggers_ : reinterpret_cast<::subspace::GetTriggersResponse&>(::subspace::_GetTriggersResponse_default_instance_); +} +inline const ::subspace::GetTriggersResponse& Response::get_triggers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.get_triggers) + return _internal_get_triggers(); +} +inline ::subspace::GetTriggersResponse* Response::unsafe_arena_release_get_triggers() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.get_triggers) + if (response_case() == kGetTriggers) { + clear_has_response(); + auto* temp = _impl_.response_.get_triggers_; + _impl_.response_.get_triggers_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_get_triggers(::subspace::GetTriggersResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_get_triggers(); + _impl_.response_.get_triggers_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.get_triggers) +} +inline ::subspace::GetTriggersResponse* Response::_internal_mutable_get_triggers() { + if (response_case() != kGetTriggers) { + clear_response(); + set_has_get_triggers(); + _impl_.response_.get_triggers_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::GetTriggersResponse>(GetArena()); + } + return _impl_.response_.get_triggers_; +} +inline ::subspace::GetTriggersResponse* Response::mutable_get_triggers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::GetTriggersResponse* _msg = _internal_mutable_get_triggers(); + // @@protoc_insertion_point(field_mutable:subspace.Response.get_triggers) + return _msg; +} + +// .subspace.RemovePublisherResponse remove_publisher = 5; +inline bool Response::has_remove_publisher() const { + return response_case() == kRemovePublisher; +} +inline bool Response::_internal_has_remove_publisher() const { + return response_case() == kRemovePublisher; +} +inline void Response::set_has_remove_publisher() { + _impl_._oneof_case_[0] = kRemovePublisher; +} +inline void Response::clear_remove_publisher() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kRemovePublisher) { + if (GetArena() == nullptr) { + delete _impl_.response_.remove_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.remove_publisher_); + } + clear_has_response(); + } +} +inline ::subspace::RemovePublisherResponse* Response::release_remove_publisher() { + // @@protoc_insertion_point(field_release:subspace.Response.remove_publisher) + if (response_case() == kRemovePublisher) { + clear_has_response(); + auto* temp = _impl_.response_.remove_publisher_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.remove_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RemovePublisherResponse& Response::_internal_remove_publisher() const { + return response_case() == kRemovePublisher ? *_impl_.response_.remove_publisher_ : reinterpret_cast<::subspace::RemovePublisherResponse&>(::subspace::_RemovePublisherResponse_default_instance_); +} +inline const ::subspace::RemovePublisherResponse& Response::remove_publisher() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.remove_publisher) + return _internal_remove_publisher(); +} +inline ::subspace::RemovePublisherResponse* Response::unsafe_arena_release_remove_publisher() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.remove_publisher) + if (response_case() == kRemovePublisher) { + clear_has_response(); + auto* temp = _impl_.response_.remove_publisher_; + _impl_.response_.remove_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_remove_publisher(::subspace::RemovePublisherResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_remove_publisher(); + _impl_.response_.remove_publisher_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.remove_publisher) +} +inline ::subspace::RemovePublisherResponse* Response::_internal_mutable_remove_publisher() { + if (response_case() != kRemovePublisher) { + clear_response(); + set_has_remove_publisher(); + _impl_.response_.remove_publisher_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RemovePublisherResponse>(GetArena()); + } + return _impl_.response_.remove_publisher_; +} +inline ::subspace::RemovePublisherResponse* Response::mutable_remove_publisher() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RemovePublisherResponse* _msg = _internal_mutable_remove_publisher(); + // @@protoc_insertion_point(field_mutable:subspace.Response.remove_publisher) + return _msg; +} + +// .subspace.RemoveSubscriberResponse remove_subscriber = 6; +inline bool Response::has_remove_subscriber() const { + return response_case() == kRemoveSubscriber; +} +inline bool Response::_internal_has_remove_subscriber() const { + return response_case() == kRemoveSubscriber; +} +inline void Response::set_has_remove_subscriber() { + _impl_._oneof_case_[0] = kRemoveSubscriber; +} +inline void Response::clear_remove_subscriber() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kRemoveSubscriber) { + if (GetArena() == nullptr) { + delete _impl_.response_.remove_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.remove_subscriber_); + } + clear_has_response(); + } +} +inline ::subspace::RemoveSubscriberResponse* Response::release_remove_subscriber() { + // @@protoc_insertion_point(field_release:subspace.Response.remove_subscriber) + if (response_case() == kRemoveSubscriber) { + clear_has_response(); + auto* temp = _impl_.response_.remove_subscriber_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.remove_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RemoveSubscriberResponse& Response::_internal_remove_subscriber() const { + return response_case() == kRemoveSubscriber ? *_impl_.response_.remove_subscriber_ : reinterpret_cast<::subspace::RemoveSubscriberResponse&>(::subspace::_RemoveSubscriberResponse_default_instance_); +} +inline const ::subspace::RemoveSubscriberResponse& Response::remove_subscriber() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.remove_subscriber) + return _internal_remove_subscriber(); +} +inline ::subspace::RemoveSubscriberResponse* Response::unsafe_arena_release_remove_subscriber() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.remove_subscriber) + if (response_case() == kRemoveSubscriber) { + clear_has_response(); + auto* temp = _impl_.response_.remove_subscriber_; + _impl_.response_.remove_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_remove_subscriber(::subspace::RemoveSubscriberResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_remove_subscriber(); + _impl_.response_.remove_subscriber_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.remove_subscriber) +} +inline ::subspace::RemoveSubscriberResponse* Response::_internal_mutable_remove_subscriber() { + if (response_case() != kRemoveSubscriber) { + clear_response(); + set_has_remove_subscriber(); + _impl_.response_.remove_subscriber_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RemoveSubscriberResponse>(GetArena()); + } + return _impl_.response_.remove_subscriber_; +} +inline ::subspace::RemoveSubscriberResponse* Response::mutable_remove_subscriber() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RemoveSubscriberResponse* _msg = _internal_mutable_remove_subscriber(); + // @@protoc_insertion_point(field_mutable:subspace.Response.remove_subscriber) + return _msg; +} + +// .subspace.GetChannelInfoResponse get_channel_info = 9; +inline bool Response::has_get_channel_info() const { + return response_case() == kGetChannelInfo; +} +inline bool Response::_internal_has_get_channel_info() const { + return response_case() == kGetChannelInfo; +} +inline void Response::set_has_get_channel_info() { + _impl_._oneof_case_[0] = kGetChannelInfo; +} +inline void Response::clear_get_channel_info() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kGetChannelInfo) { + if (GetArena() == nullptr) { + delete _impl_.response_.get_channel_info_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.get_channel_info_); + } + clear_has_response(); + } +} +inline ::subspace::GetChannelInfoResponse* Response::release_get_channel_info() { + // @@protoc_insertion_point(field_release:subspace.Response.get_channel_info) + if (response_case() == kGetChannelInfo) { + clear_has_response(); + auto* temp = _impl_.response_.get_channel_info_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.get_channel_info_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::GetChannelInfoResponse& Response::_internal_get_channel_info() const { + return response_case() == kGetChannelInfo ? *_impl_.response_.get_channel_info_ : reinterpret_cast<::subspace::GetChannelInfoResponse&>(::subspace::_GetChannelInfoResponse_default_instance_); +} +inline const ::subspace::GetChannelInfoResponse& Response::get_channel_info() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.get_channel_info) + return _internal_get_channel_info(); +} +inline ::subspace::GetChannelInfoResponse* Response::unsafe_arena_release_get_channel_info() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.get_channel_info) + if (response_case() == kGetChannelInfo) { + clear_has_response(); + auto* temp = _impl_.response_.get_channel_info_; + _impl_.response_.get_channel_info_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_get_channel_info(::subspace::GetChannelInfoResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_get_channel_info(); + _impl_.response_.get_channel_info_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.get_channel_info) +} +inline ::subspace::GetChannelInfoResponse* Response::_internal_mutable_get_channel_info() { + if (response_case() != kGetChannelInfo) { + clear_response(); + set_has_get_channel_info(); + _impl_.response_.get_channel_info_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::GetChannelInfoResponse>(GetArena()); + } + return _impl_.response_.get_channel_info_; +} +inline ::subspace::GetChannelInfoResponse* Response::mutable_get_channel_info() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::GetChannelInfoResponse* _msg = _internal_mutable_get_channel_info(); + // @@protoc_insertion_point(field_mutable:subspace.Response.get_channel_info) + return _msg; +} + +// .subspace.GetChannelStatsResponse get_channel_stats = 10; +inline bool Response::has_get_channel_stats() const { + return response_case() == kGetChannelStats; +} +inline bool Response::_internal_has_get_channel_stats() const { + return response_case() == kGetChannelStats; +} +inline void Response::set_has_get_channel_stats() { + _impl_._oneof_case_[0] = kGetChannelStats; +} +inline void Response::clear_get_channel_stats() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kGetChannelStats) { + if (GetArena() == nullptr) { + delete _impl_.response_.get_channel_stats_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.get_channel_stats_); + } + clear_has_response(); + } +} +inline ::subspace::GetChannelStatsResponse* Response::release_get_channel_stats() { + // @@protoc_insertion_point(field_release:subspace.Response.get_channel_stats) + if (response_case() == kGetChannelStats) { + clear_has_response(); + auto* temp = _impl_.response_.get_channel_stats_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.get_channel_stats_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::GetChannelStatsResponse& Response::_internal_get_channel_stats() const { + return response_case() == kGetChannelStats ? *_impl_.response_.get_channel_stats_ : reinterpret_cast<::subspace::GetChannelStatsResponse&>(::subspace::_GetChannelStatsResponse_default_instance_); +} +inline const ::subspace::GetChannelStatsResponse& Response::get_channel_stats() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Response.get_channel_stats) + return _internal_get_channel_stats(); +} +inline ::subspace::GetChannelStatsResponse* Response::unsafe_arena_release_get_channel_stats() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Response.get_channel_stats) + if (response_case() == kGetChannelStats) { + clear_has_response(); + auto* temp = _impl_.response_.get_channel_stats_; + _impl_.response_.get_channel_stats_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Response::unsafe_arena_set_allocated_get_channel_stats(::subspace::GetChannelStatsResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_get_channel_stats(); + _impl_.response_.get_channel_stats_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Response.get_channel_stats) +} +inline ::subspace::GetChannelStatsResponse* Response::_internal_mutable_get_channel_stats() { + if (response_case() != kGetChannelStats) { + clear_response(); + set_has_get_channel_stats(); + _impl_.response_.get_channel_stats_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::GetChannelStatsResponse>(GetArena()); + } + return _impl_.response_.get_channel_stats_; +} +inline ::subspace::GetChannelStatsResponse* Response::mutable_get_channel_stats() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::GetChannelStatsResponse* _msg = _internal_mutable_get_channel_stats(); + // @@protoc_insertion_point(field_mutable:subspace.Response.get_channel_stats) + return _msg; +} + +inline bool Response::has_response() const { + return response_case() != RESPONSE_NOT_SET; +} +inline void Response::clear_has_response() { + _impl_._oneof_case_[0] = RESPONSE_NOT_SET; +} +inline Response::ResponseCase Response::response_case() const { + return Response::ResponseCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ChannelInfoProto + +// string name = 1; +inline void ChannelInfoProto::clear_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.ClearToEmpty(); +} +inline const std::string& ChannelInfoProto::name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ChannelInfoProto::set_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.name) +} +inline std::string* ChannelInfoProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:subspace.ChannelInfoProto.name) + return _s; +} +inline const std::string& ChannelInfoProto::_internal_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.name_.Get(); +} +inline void ChannelInfoProto::_internal_set_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(value, GetArena()); +} +inline std::string* ChannelInfoProto::_internal_mutable_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.name_.Mutable( GetArena()); +} +inline std::string* ChannelInfoProto::release_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ChannelInfoProto.name) + return _impl_.name_.Release(); +} +inline void ChannelInfoProto::set_allocated_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ChannelInfoProto.name) +} + +// int32 slot_size = 2; +inline void ChannelInfoProto::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t ChannelInfoProto::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.slot_size) + return _internal_slot_size(); +} +inline void ChannelInfoProto::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.slot_size) +} +inline ::int32_t ChannelInfoProto::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void ChannelInfoProto::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// int32 num_slots = 3; +inline void ChannelInfoProto::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t ChannelInfoProto::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_slots) + return _internal_num_slots(); +} +inline void ChannelInfoProto::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_slots) +} +inline ::int32_t ChannelInfoProto::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void ChannelInfoProto::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// bytes type = 4; +inline void ChannelInfoProto::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& ChannelInfoProto::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ChannelInfoProto::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.type) +} +inline std::string* ChannelInfoProto::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.ChannelInfoProto.type) + return _s; +} +inline const std::string& ChannelInfoProto::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void ChannelInfoProto::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* ChannelInfoProto::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* ChannelInfoProto::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ChannelInfoProto.type) + return _impl_.type_.Release(); +} +inline void ChannelInfoProto::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ChannelInfoProto.type) +} + +// int32 num_pubs = 5; +inline void ChannelInfoProto::clear_num_pubs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_pubs_ = 0; +} +inline ::int32_t ChannelInfoProto::num_pubs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_pubs) + return _internal_num_pubs(); +} +inline void ChannelInfoProto::set_num_pubs(::int32_t value) { + _internal_set_num_pubs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_pubs) +} +inline ::int32_t ChannelInfoProto::_internal_num_pubs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_pubs_; +} +inline void ChannelInfoProto::_internal_set_num_pubs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_pubs_ = value; +} + +// int32 num_subs = 6; +inline void ChannelInfoProto::clear_num_subs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_subs_ = 0; +} +inline ::int32_t ChannelInfoProto::num_subs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_subs) + return _internal_num_subs(); +} +inline void ChannelInfoProto::set_num_subs(::int32_t value) { + _internal_set_num_subs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_subs) +} +inline ::int32_t ChannelInfoProto::_internal_num_subs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_subs_; +} +inline void ChannelInfoProto::_internal_set_num_subs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_subs_ = value; +} + +// int32 num_bridge_pubs = 7; +inline void ChannelInfoProto::clear_num_bridge_pubs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_pubs_ = 0; +} +inline ::int32_t ChannelInfoProto::num_bridge_pubs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_bridge_pubs) + return _internal_num_bridge_pubs(); +} +inline void ChannelInfoProto::set_num_bridge_pubs(::int32_t value) { + _internal_set_num_bridge_pubs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_bridge_pubs) +} +inline ::int32_t ChannelInfoProto::_internal_num_bridge_pubs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_bridge_pubs_; +} +inline void ChannelInfoProto::_internal_set_num_bridge_pubs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_pubs_ = value; +} + +// int32 num_bridge_subs = 8; +inline void ChannelInfoProto::clear_num_bridge_subs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_subs_ = 0; +} +inline ::int32_t ChannelInfoProto::num_bridge_subs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_bridge_subs) + return _internal_num_bridge_subs(); +} +inline void ChannelInfoProto::set_num_bridge_subs(::int32_t value) { + _internal_set_num_bridge_subs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_bridge_subs) +} +inline ::int32_t ChannelInfoProto::_internal_num_bridge_subs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_bridge_subs_; +} +inline void ChannelInfoProto::_internal_set_num_bridge_subs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_subs_ = value; +} + +// bool is_reliable = 9; +inline void ChannelInfoProto::clear_is_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = false; +} +inline bool ChannelInfoProto::is_reliable() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.is_reliable) + return _internal_is_reliable(); +} +inline void ChannelInfoProto::set_is_reliable(bool value) { + _internal_set_is_reliable(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.is_reliable) +} +inline bool ChannelInfoProto::_internal_is_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_reliable_; +} +inline void ChannelInfoProto::_internal_set_is_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = value; +} + +// int32 num_tunnel_pubs = 13; +inline void ChannelInfoProto::clear_num_tunnel_pubs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_tunnel_pubs_ = 0; +} +inline ::int32_t ChannelInfoProto::num_tunnel_pubs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_tunnel_pubs) + return _internal_num_tunnel_pubs(); +} +inline void ChannelInfoProto::set_num_tunnel_pubs(::int32_t value) { + _internal_set_num_tunnel_pubs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_tunnel_pubs) +} +inline ::int32_t ChannelInfoProto::_internal_num_tunnel_pubs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_tunnel_pubs_; +} +inline void ChannelInfoProto::_internal_set_num_tunnel_pubs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_tunnel_pubs_ = value; +} + +// int32 num_tunnel_subs = 14; +inline void ChannelInfoProto::clear_num_tunnel_subs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_tunnel_subs_ = 0; +} +inline ::int32_t ChannelInfoProto::num_tunnel_subs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.num_tunnel_subs) + return _internal_num_tunnel_subs(); +} +inline void ChannelInfoProto::set_num_tunnel_subs(::int32_t value) { + _internal_set_num_tunnel_subs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.num_tunnel_subs) +} +inline ::int32_t ChannelInfoProto::_internal_num_tunnel_subs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_tunnel_subs_; +} +inline void ChannelInfoProto::_internal_set_num_tunnel_subs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_tunnel_subs_ = value; +} + +// bool is_virtual = 10; +inline void ChannelInfoProto::clear_is_virtual() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_virtual_ = false; +} +inline bool ChannelInfoProto::is_virtual() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.is_virtual) + return _internal_is_virtual(); +} +inline void ChannelInfoProto::set_is_virtual(bool value) { + _internal_set_is_virtual(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.is_virtual) +} +inline bool ChannelInfoProto::_internal_is_virtual() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_virtual_; +} +inline void ChannelInfoProto::_internal_set_is_virtual(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_virtual_ = value; +} + +// int32 vchan_id = 11; +inline void ChannelInfoProto::clear_vchan_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = 0; +} +inline ::int32_t ChannelInfoProto::vchan_id() const { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.vchan_id) + return _internal_vchan_id(); +} +inline void ChannelInfoProto::set_vchan_id(::int32_t value) { + _internal_set_vchan_id(value); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.vchan_id) +} +inline ::int32_t ChannelInfoProto::_internal_vchan_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vchan_id_; +} +inline void ChannelInfoProto::_internal_set_vchan_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = value; +} + +// string mux = 12; +inline void ChannelInfoProto::clear_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.ClearToEmpty(); +} +inline const std::string& ChannelInfoProto::mux() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelInfoProto.mux) + return _internal_mux(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ChannelInfoProto::set_mux(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ChannelInfoProto.mux) +} +inline std::string* ChannelInfoProto::mutable_mux() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_mux(); + // @@protoc_insertion_point(field_mutable:subspace.ChannelInfoProto.mux) + return _s; +} +inline const std::string& ChannelInfoProto::_internal_mux() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.mux_.Get(); +} +inline void ChannelInfoProto::_internal_set_mux(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(value, GetArena()); +} +inline std::string* ChannelInfoProto::_internal_mutable_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.mux_.Mutable( GetArena()); +} +inline std::string* ChannelInfoProto::release_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ChannelInfoProto.mux) + return _impl_.mux_.Release(); +} +inline void ChannelInfoProto::set_allocated_mux(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.mux_.IsDefault()) { + _impl_.mux_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ChannelInfoProto.mux) +} + +// ------------------------------------------------------------------- + +// ChannelDirectory + +// string server_id = 1; +inline void ChannelDirectory::clear_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.ClearToEmpty(); +} +inline const std::string& ChannelDirectory::server_id() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelDirectory.server_id) + return _internal_server_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ChannelDirectory::set_server_id(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ChannelDirectory.server_id) +} +inline std::string* ChannelDirectory::mutable_server_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_server_id(); + // @@protoc_insertion_point(field_mutable:subspace.ChannelDirectory.server_id) + return _s; +} +inline const std::string& ChannelDirectory::_internal_server_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.server_id_.Get(); +} +inline void ChannelDirectory::_internal_set_server_id(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.Set(value, GetArena()); +} +inline std::string* ChannelDirectory::_internal_mutable_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.server_id_.Mutable( GetArena()); +} +inline std::string* ChannelDirectory::release_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ChannelDirectory.server_id) + return _impl_.server_id_.Release(); +} +inline void ChannelDirectory::set_allocated_server_id(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.server_id_.IsDefault()) { + _impl_.server_id_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ChannelDirectory.server_id) +} + +// repeated .subspace.ChannelInfoProto channels = 2; +inline int ChannelDirectory::_internal_channels_size() const { + return _internal_channels().size(); +} +inline int ChannelDirectory::channels_size() const { + return _internal_channels_size(); +} +inline void ChannelDirectory::clear_channels() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channels_.Clear(); +} +inline ::subspace::ChannelInfoProto* ChannelDirectory::mutable_channels(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:subspace.ChannelDirectory.channels) + return _internal_mutable_channels()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* ChannelDirectory::mutable_channels() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.ChannelDirectory.channels) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_channels(); +} +inline const ::subspace::ChannelInfoProto& ChannelDirectory::channels(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelDirectory.channels) + return _internal_channels().Get(index); +} +inline ::subspace::ChannelInfoProto* ChannelDirectory::add_channels() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::subspace::ChannelInfoProto* _add = _internal_mutable_channels()->Add(); + // @@protoc_insertion_point(field_add:subspace.ChannelDirectory.channels) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& ChannelDirectory::channels() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.ChannelDirectory.channels) + return _internal_channels(); +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>& +ChannelDirectory::_internal_channels() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channels_; +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelInfoProto>* +ChannelDirectory::_internal_mutable_channels() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.channels_; +} + +// ------------------------------------------------------------------- + +// ChannelStatsProto + +// string channel_name = 1; +inline void ChannelStatsProto::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ChannelStatsProto::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ChannelStatsProto::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.channel_name) +} +inline std::string* ChannelStatsProto::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ChannelStatsProto.channel_name) + return _s; +} +inline const std::string& ChannelStatsProto::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ChannelStatsProto::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ChannelStatsProto::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ChannelStatsProto::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ChannelStatsProto.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ChannelStatsProto::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ChannelStatsProto.channel_name) +} + +// int64 total_bytes = 2; +inline void ChannelStatsProto::clear_total_bytes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.total_bytes_ = ::int64_t{0}; +} +inline ::int64_t ChannelStatsProto::total_bytes() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.total_bytes) + return _internal_total_bytes(); +} +inline void ChannelStatsProto::set_total_bytes(::int64_t value) { + _internal_set_total_bytes(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.total_bytes) +} +inline ::int64_t ChannelStatsProto::_internal_total_bytes() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.total_bytes_; +} +inline void ChannelStatsProto::_internal_set_total_bytes(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.total_bytes_ = value; +} + +// int64 total_messages = 3; +inline void ChannelStatsProto::clear_total_messages() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.total_messages_ = ::int64_t{0}; +} +inline ::int64_t ChannelStatsProto::total_messages() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.total_messages) + return _internal_total_messages(); +} +inline void ChannelStatsProto::set_total_messages(::int64_t value) { + _internal_set_total_messages(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.total_messages) +} +inline ::int64_t ChannelStatsProto::_internal_total_messages() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.total_messages_; +} +inline void ChannelStatsProto::_internal_set_total_messages(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.total_messages_ = value; +} + +// int32 slot_size = 4; +inline void ChannelStatsProto::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t ChannelStatsProto::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.slot_size) + return _internal_slot_size(); +} +inline void ChannelStatsProto::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.slot_size) +} +inline ::int32_t ChannelStatsProto::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void ChannelStatsProto::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// int32 num_slots = 5; +inline void ChannelStatsProto::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t ChannelStatsProto::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.num_slots) + return _internal_num_slots(); +} +inline void ChannelStatsProto::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.num_slots) +} +inline ::int32_t ChannelStatsProto::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void ChannelStatsProto::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// int32 num_pubs = 6; +inline void ChannelStatsProto::clear_num_pubs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_pubs_ = 0; +} +inline ::int32_t ChannelStatsProto::num_pubs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.num_pubs) + return _internal_num_pubs(); +} +inline void ChannelStatsProto::set_num_pubs(::int32_t value) { + _internal_set_num_pubs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.num_pubs) +} +inline ::int32_t ChannelStatsProto::_internal_num_pubs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_pubs_; +} +inline void ChannelStatsProto::_internal_set_num_pubs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_pubs_ = value; +} + +// int32 num_subs = 7; +inline void ChannelStatsProto::clear_num_subs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_subs_ = 0; +} +inline ::int32_t ChannelStatsProto::num_subs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.num_subs) + return _internal_num_subs(); +} +inline void ChannelStatsProto::set_num_subs(::int32_t value) { + _internal_set_num_subs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.num_subs) +} +inline ::int32_t ChannelStatsProto::_internal_num_subs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_subs_; +} +inline void ChannelStatsProto::_internal_set_num_subs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_subs_ = value; +} + +// uint32 max_message_size = 8; +inline void ChannelStatsProto::clear_max_message_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_message_size_ = 0u; +} +inline ::uint32_t ChannelStatsProto::max_message_size() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.max_message_size) + return _internal_max_message_size(); +} +inline void ChannelStatsProto::set_max_message_size(::uint32_t value) { + _internal_set_max_message_size(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.max_message_size) +} +inline ::uint32_t ChannelStatsProto::_internal_max_message_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_message_size_; +} +inline void ChannelStatsProto::_internal_set_max_message_size(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_message_size_ = value; +} + +// uint32 total_drops = 9; +inline void ChannelStatsProto::clear_total_drops() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.total_drops_ = 0u; +} +inline ::uint32_t ChannelStatsProto::total_drops() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.total_drops) + return _internal_total_drops(); +} +inline void ChannelStatsProto::set_total_drops(::uint32_t value) { + _internal_set_total_drops(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.total_drops) +} +inline ::uint32_t ChannelStatsProto::_internal_total_drops() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.total_drops_; +} +inline void ChannelStatsProto::_internal_set_total_drops(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.total_drops_ = value; +} + +// int32 num_bridge_pubs = 10; +inline void ChannelStatsProto::clear_num_bridge_pubs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_pubs_ = 0; +} +inline ::int32_t ChannelStatsProto::num_bridge_pubs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.num_bridge_pubs) + return _internal_num_bridge_pubs(); +} +inline void ChannelStatsProto::set_num_bridge_pubs(::int32_t value) { + _internal_set_num_bridge_pubs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.num_bridge_pubs) +} +inline ::int32_t ChannelStatsProto::_internal_num_bridge_pubs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_bridge_pubs_; +} +inline void ChannelStatsProto::_internal_set_num_bridge_pubs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_pubs_ = value; +} + +// int32 num_bridge_subs = 11; +inline void ChannelStatsProto::clear_num_bridge_subs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_subs_ = 0; +} +inline ::int32_t ChannelStatsProto::num_bridge_subs() const { + // @@protoc_insertion_point(field_get:subspace.ChannelStatsProto.num_bridge_subs) + return _internal_num_bridge_subs(); +} +inline void ChannelStatsProto::set_num_bridge_subs(::int32_t value) { + _internal_set_num_bridge_subs(value); + // @@protoc_insertion_point(field_set:subspace.ChannelStatsProto.num_bridge_subs) +} +inline ::int32_t ChannelStatsProto::_internal_num_bridge_subs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_bridge_subs_; +} +inline void ChannelStatsProto::_internal_set_num_bridge_subs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_bridge_subs_ = value; +} + +// ------------------------------------------------------------------- + +// Statistics + +// string server_id = 1; +inline void Statistics::clear_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.ClearToEmpty(); +} +inline const std::string& Statistics::server_id() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Statistics.server_id) + return _internal_server_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Statistics::set_server_id(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.Statistics.server_id) +} +inline std::string* Statistics::mutable_server_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_server_id(); + // @@protoc_insertion_point(field_mutable:subspace.Statistics.server_id) + return _s; +} +inline const std::string& Statistics::_internal_server_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.server_id_.Get(); +} +inline void Statistics::_internal_set_server_id(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.Set(value, GetArena()); +} +inline std::string* Statistics::_internal_mutable_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.server_id_.Mutable( GetArena()); +} +inline std::string* Statistics::release_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Statistics.server_id) + return _impl_.server_id_.Release(); +} +inline void Statistics::set_allocated_server_id(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.server_id_.IsDefault()) { + _impl_.server_id_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.Statistics.server_id) +} + +// int64 timestamp = 2; +inline void Statistics::clear_timestamp() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.timestamp_ = ::int64_t{0}; +} +inline ::int64_t Statistics::timestamp() const { + // @@protoc_insertion_point(field_get:subspace.Statistics.timestamp) + return _internal_timestamp(); +} +inline void Statistics::set_timestamp(::int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:subspace.Statistics.timestamp) +} +inline ::int64_t Statistics::_internal_timestamp() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.timestamp_; +} +inline void Statistics::_internal_set_timestamp(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.timestamp_ = value; +} + +// repeated .subspace.ChannelStatsProto channels = 3; +inline int Statistics::_internal_channels_size() const { + return _internal_channels().size(); +} +inline int Statistics::channels_size() const { + return _internal_channels_size(); +} +inline void Statistics::clear_channels() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channels_.Clear(); +} +inline ::subspace::ChannelStatsProto* Statistics::mutable_channels(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:subspace.Statistics.channels) + return _internal_mutable_channels()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* Statistics::mutable_channels() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.Statistics.channels) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_channels(); +} +inline const ::subspace::ChannelStatsProto& Statistics::channels(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Statistics.channels) + return _internal_channels().Get(index); +} +inline ::subspace::ChannelStatsProto* Statistics::add_channels() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::subspace::ChannelStatsProto* _add = _internal_mutable_channels()->Add(); + // @@protoc_insertion_point(field_add:subspace.Statistics.channels) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& Statistics::channels() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.Statistics.channels) + return _internal_channels(); +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>& +Statistics::_internal_channels() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channels_; +} +inline ::google::protobuf::RepeatedPtrField<::subspace::ChannelStatsProto>* +Statistics::_internal_mutable_channels() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.channels_; +} + +// ------------------------------------------------------------------- + +// ChannelAddress + +// bytes address = 1; +inline void ChannelAddress::clear_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.address_.ClearToEmpty(); +} +inline const std::string& ChannelAddress::address() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ChannelAddress.address) + return _internal_address(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ChannelAddress::set_address(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.address_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ChannelAddress.address) +} +inline std::string* ChannelAddress::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_address(); + // @@protoc_insertion_point(field_mutable:subspace.ChannelAddress.address) + return _s; +} +inline const std::string& ChannelAddress::_internal_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.address_.Get(); +} +inline void ChannelAddress::_internal_set_address(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.address_.Set(value, GetArena()); +} +inline std::string* ChannelAddress::_internal_mutable_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.address_.Mutable( GetArena()); +} +inline std::string* ChannelAddress::release_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ChannelAddress.address) + return _impl_.address_.Release(); +} +inline void ChannelAddress::set_allocated_address(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.address_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.address_.IsDefault()) { + _impl_.address_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ChannelAddress.address) +} + +// int32 port = 2; +inline void ChannelAddress::clear_port() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = 0; +} +inline ::int32_t ChannelAddress::port() const { + // @@protoc_insertion_point(field_get:subspace.ChannelAddress.port) + return _internal_port(); +} +inline void ChannelAddress::set_port(::int32_t value) { + _internal_set_port(value); + // @@protoc_insertion_point(field_set:subspace.ChannelAddress.port) +} +inline ::int32_t ChannelAddress::_internal_port() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.port_; +} +inline void ChannelAddress::_internal_set_port(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = value; +} + +// ------------------------------------------------------------------- + +// Subscribed + +// string channel_name = 1; +inline void Subscribed::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& Subscribed::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Subscribed.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Subscribed::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.Subscribed.channel_name) +} +inline std::string* Subscribed::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.Subscribed.channel_name) + return _s; +} +inline const std::string& Subscribed::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void Subscribed::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* Subscribed::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* Subscribed::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Subscribed.channel_name) + return _impl_.channel_name_.Release(); +} +inline void Subscribed::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.Subscribed.channel_name) +} + +// int32 slot_size = 2; +inline void Subscribed::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t Subscribed::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.slot_size) + return _internal_slot_size(); +} +inline void Subscribed::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.slot_size) +} +inline ::int32_t Subscribed::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void Subscribed::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// int32 num_slots = 3; +inline void Subscribed::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t Subscribed::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.num_slots) + return _internal_num_slots(); +} +inline void Subscribed::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.num_slots) +} +inline ::int32_t Subscribed::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void Subscribed::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// bool reliable = 4; +inline void Subscribed::clear_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_ = false; +} +inline bool Subscribed::reliable() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.reliable) + return _internal_reliable(); +} +inline void Subscribed::set_reliable(bool value) { + _internal_set_reliable(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.reliable) +} +inline bool Subscribed::_internal_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reliable_; +} +inline void Subscribed::_internal_set_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_ = value; +} + +// bool notify_retirement = 5; +inline void Subscribed::clear_notify_retirement() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = false; +} +inline bool Subscribed::notify_retirement() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.notify_retirement) + return _internal_notify_retirement(); +} +inline void Subscribed::set_notify_retirement(bool value) { + _internal_set_notify_retirement(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.notify_retirement) +} +inline bool Subscribed::_internal_notify_retirement() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.notify_retirement_; +} +inline void Subscribed::_internal_set_notify_retirement(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = value; +} + +// .subspace.ChannelAddress retirement_socket = 6; +inline bool Subscribed::has_retirement_socket() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.retirement_socket_ != nullptr); + return value; +} +inline void Subscribed::clear_retirement_socket() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.retirement_socket_ != nullptr) _impl_.retirement_socket_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::subspace::ChannelAddress& Subscribed::_internal_retirement_socket() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::subspace::ChannelAddress* p = _impl_.retirement_socket_; + return p != nullptr ? *p : reinterpret_cast(::subspace::_ChannelAddress_default_instance_); +} +inline const ::subspace::ChannelAddress& Subscribed::retirement_socket() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Subscribed.retirement_socket) + return _internal_retirement_socket(); +} +inline void Subscribed::unsafe_arena_set_allocated_retirement_socket(::subspace::ChannelAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.retirement_socket_); + } + _impl_.retirement_socket_ = reinterpret_cast<::subspace::ChannelAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Subscribed.retirement_socket) +} +inline ::subspace::ChannelAddress* Subscribed::release_retirement_socket() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ChannelAddress* released = _impl_.retirement_socket_; + _impl_.retirement_socket_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::subspace::ChannelAddress* Subscribed::unsafe_arena_release_retirement_socket() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Subscribed.retirement_socket) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ChannelAddress* temp = _impl_.retirement_socket_; + _impl_.retirement_socket_ = nullptr; + return temp; +} +inline ::subspace::ChannelAddress* Subscribed::_internal_mutable_retirement_socket() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.retirement_socket_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::subspace::ChannelAddress>(GetArena()); + _impl_.retirement_socket_ = reinterpret_cast<::subspace::ChannelAddress*>(p); + } + return _impl_.retirement_socket_; +} +inline ::subspace::ChannelAddress* Subscribed::mutable_retirement_socket() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::subspace::ChannelAddress* _msg = _internal_mutable_retirement_socket(); + // @@protoc_insertion_point(field_mutable:subspace.Subscribed.retirement_socket) + return _msg; +} +inline void Subscribed::set_allocated_retirement_socket(::subspace::ChannelAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.retirement_socket_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.retirement_socket_ = reinterpret_cast<::subspace::ChannelAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.Subscribed.retirement_socket) +} + +// int32 checksum_size = 7; +inline void Subscribed::clear_checksum_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = 0; +} +inline ::int32_t Subscribed::checksum_size() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.checksum_size) + return _internal_checksum_size(); +} +inline void Subscribed::set_checksum_size(::int32_t value) { + _internal_set_checksum_size(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.checksum_size) +} +inline ::int32_t Subscribed::_internal_checksum_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.checksum_size_; +} +inline void Subscribed::_internal_set_checksum_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = value; +} + +// int32 metadata_size = 8; +inline void Subscribed::clear_metadata_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = 0; +} +inline ::int32_t Subscribed::metadata_size() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.metadata_size) + return _internal_metadata_size(); +} +inline void Subscribed::set_metadata_size(::int32_t value) { + _internal_set_metadata_size(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.metadata_size) +} +inline ::int32_t Subscribed::_internal_metadata_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.metadata_size_; +} +inline void Subscribed::_internal_set_metadata_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = value; +} + +// bool split_buffers = 9; +inline void Subscribed::clear_split_buffers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_ = false; +} +inline bool Subscribed::split_buffers() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.split_buffers) + return _internal_split_buffers(); +} +inline void Subscribed::set_split_buffers(bool value) { + _internal_set_split_buffers(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.split_buffers) +} +inline bool Subscribed::_internal_split_buffers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.split_buffers_; +} +inline void Subscribed::_internal_set_split_buffers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_ = value; +} + +// bool split_buffers_over_bridge = 10; +inline void Subscribed::clear_split_buffers_over_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = false; +} +inline bool Subscribed::split_buffers_over_bridge() const { + // @@protoc_insertion_point(field_get:subspace.Subscribed.split_buffers_over_bridge) + return _internal_split_buffers_over_bridge(); +} +inline void Subscribed::set_split_buffers_over_bridge(bool value) { + _internal_set_split_buffers_over_bridge(value); + // @@protoc_insertion_point(field_set:subspace.Subscribed.split_buffers_over_bridge) +} +inline bool Subscribed::_internal_split_buffers_over_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.split_buffers_over_bridge_; +} +inline void Subscribed::_internal_set_split_buffers_over_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = value; +} + +// ------------------------------------------------------------------- + +// RetirementNotification + +// int32 slot_id = 1; +inline void RetirementNotification::clear_slot_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_id_ = 0; +} +inline ::int32_t RetirementNotification::slot_id() const { + // @@protoc_insertion_point(field_get:subspace.RetirementNotification.slot_id) + return _internal_slot_id(); +} +inline void RetirementNotification::set_slot_id(::int32_t value) { + _internal_set_slot_id(value); + // @@protoc_insertion_point(field_set:subspace.RetirementNotification.slot_id) +} +inline ::int32_t RetirementNotification::_internal_slot_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_id_; +} +inline void RetirementNotification::_internal_set_slot_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_id_ = value; +} + +// ------------------------------------------------------------------- + +// Discovery_Query + +// string channel_name = 1; +inline void Discovery_Query::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& Discovery_Query::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.Query.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Discovery_Query::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.Discovery.Query.channel_name) +} +inline std::string* Discovery_Query::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.Query.channel_name) + return _s; +} +inline const std::string& Discovery_Query::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void Discovery_Query::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* Discovery_Query::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* Discovery_Query::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Discovery.Query.channel_name) + return _impl_.channel_name_.Release(); +} +inline void Discovery_Query::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.Query.channel_name) +} + +// ------------------------------------------------------------------- + +// Discovery_Advertise + +// string channel_name = 1; +inline void Discovery_Advertise::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& Discovery_Advertise::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.Advertise.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Discovery_Advertise::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.Discovery.Advertise.channel_name) +} +inline std::string* Discovery_Advertise::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.Advertise.channel_name) + return _s; +} +inline const std::string& Discovery_Advertise::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void Discovery_Advertise::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* Discovery_Advertise::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* Discovery_Advertise::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Discovery.Advertise.channel_name) + return _impl_.channel_name_.Release(); +} +inline void Discovery_Advertise::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.Advertise.channel_name) +} + +// bool reliable = 2; +inline void Discovery_Advertise::clear_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_ = false; +} +inline bool Discovery_Advertise::reliable() const { + // @@protoc_insertion_point(field_get:subspace.Discovery.Advertise.reliable) + return _internal_reliable(); +} +inline void Discovery_Advertise::set_reliable(bool value) { + _internal_set_reliable(value); + // @@protoc_insertion_point(field_set:subspace.Discovery.Advertise.reliable) +} +inline bool Discovery_Advertise::_internal_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reliable_; +} +inline void Discovery_Advertise::_internal_set_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_ = value; +} + +// bool notify_retirement = 3; +inline void Discovery_Advertise::clear_notify_retirement() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = false; +} +inline bool Discovery_Advertise::notify_retirement() const { + // @@protoc_insertion_point(field_get:subspace.Discovery.Advertise.notify_retirement) + return _internal_notify_retirement(); +} +inline void Discovery_Advertise::set_notify_retirement(bool value) { + _internal_set_notify_retirement(value); + // @@protoc_insertion_point(field_set:subspace.Discovery.Advertise.notify_retirement) +} +inline bool Discovery_Advertise::_internal_notify_retirement() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.notify_retirement_; +} +inline void Discovery_Advertise::_internal_set_notify_retirement(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = value; +} + +// bool split_buffers = 4; +inline void Discovery_Advertise::clear_split_buffers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_ = false; +} +inline bool Discovery_Advertise::split_buffers() const { + // @@protoc_insertion_point(field_get:subspace.Discovery.Advertise.split_buffers) + return _internal_split_buffers(); +} +inline void Discovery_Advertise::set_split_buffers(bool value) { + _internal_set_split_buffers(value); + // @@protoc_insertion_point(field_set:subspace.Discovery.Advertise.split_buffers) +} +inline bool Discovery_Advertise::_internal_split_buffers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.split_buffers_; +} +inline void Discovery_Advertise::_internal_set_split_buffers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_ = value; +} + +// ------------------------------------------------------------------- + +// Discovery_Subscribe + +// string channel_name = 1; +inline void Discovery_Subscribe::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& Discovery_Subscribe::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.Subscribe.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Discovery_Subscribe::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.Discovery.Subscribe.channel_name) +} +inline std::string* Discovery_Subscribe::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.Subscribe.channel_name) + return _s; +} +inline const std::string& Discovery_Subscribe::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void Discovery_Subscribe::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* Discovery_Subscribe::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* Discovery_Subscribe::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Discovery.Subscribe.channel_name) + return _impl_.channel_name_.Release(); +} +inline void Discovery_Subscribe::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.Subscribe.channel_name) +} + +// .subspace.ChannelAddress receiver = 2; +inline bool Discovery_Subscribe::has_receiver() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.receiver_ != nullptr); + return value; +} +inline void Discovery_Subscribe::clear_receiver() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.receiver_ != nullptr) _impl_.receiver_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::subspace::ChannelAddress& Discovery_Subscribe::_internal_receiver() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::subspace::ChannelAddress* p = _impl_.receiver_; + return p != nullptr ? *p : reinterpret_cast(::subspace::_ChannelAddress_default_instance_); +} +inline const ::subspace::ChannelAddress& Discovery_Subscribe::receiver() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.Subscribe.receiver) + return _internal_receiver(); +} +inline void Discovery_Subscribe::unsafe_arena_set_allocated_receiver(::subspace::ChannelAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.receiver_); + } + _impl_.receiver_ = reinterpret_cast<::subspace::ChannelAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Discovery.Subscribe.receiver) +} +inline ::subspace::ChannelAddress* Discovery_Subscribe::release_receiver() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ChannelAddress* released = _impl_.receiver_; + _impl_.receiver_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::subspace::ChannelAddress* Discovery_Subscribe::unsafe_arena_release_receiver() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Discovery.Subscribe.receiver) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ChannelAddress* temp = _impl_.receiver_; + _impl_.receiver_ = nullptr; + return temp; +} +inline ::subspace::ChannelAddress* Discovery_Subscribe::_internal_mutable_receiver() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.receiver_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::subspace::ChannelAddress>(GetArena()); + _impl_.receiver_ = reinterpret_cast<::subspace::ChannelAddress*>(p); + } + return _impl_.receiver_; +} +inline ::subspace::ChannelAddress* Discovery_Subscribe::mutable_receiver() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::subspace::ChannelAddress* _msg = _internal_mutable_receiver(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.Subscribe.receiver) + return _msg; +} +inline void Discovery_Subscribe::set_allocated_receiver(::subspace::ChannelAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.receiver_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.receiver_ = reinterpret_cast<::subspace::ChannelAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.Subscribe.receiver) +} + +// bool reliable = 3; +inline void Discovery_Subscribe::clear_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_ = false; +} +inline bool Discovery_Subscribe::reliable() const { + // @@protoc_insertion_point(field_get:subspace.Discovery.Subscribe.reliable) + return _internal_reliable(); +} +inline void Discovery_Subscribe::set_reliable(bool value) { + _internal_set_reliable(value); + // @@protoc_insertion_point(field_set:subspace.Discovery.Subscribe.reliable) +} +inline bool Discovery_Subscribe::_internal_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reliable_; +} +inline void Discovery_Subscribe::_internal_set_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reliable_ = value; +} + +// ------------------------------------------------------------------- + +// Discovery + +// string server_id = 1; +inline void Discovery::clear_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.ClearToEmpty(); +} +inline const std::string& Discovery::server_id() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.server_id) + return _internal_server_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Discovery::set_server_id(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.Discovery.server_id) +} +inline std::string* Discovery::mutable_server_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_server_id(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.server_id) + return _s; +} +inline const std::string& Discovery::_internal_server_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.server_id_.Get(); +} +inline void Discovery::_internal_set_server_id(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.Set(value, GetArena()); +} +inline std::string* Discovery::_internal_mutable_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.server_id_.Mutable( GetArena()); +} +inline std::string* Discovery::release_server_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.Discovery.server_id) + return _impl_.server_id_.Release(); +} +inline void Discovery::set_allocated_server_id(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.server_id_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.server_id_.IsDefault()) { + _impl_.server_id_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.Discovery.server_id) +} + +// int32 port = 2; +inline void Discovery::clear_port() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = 0; +} +inline ::int32_t Discovery::port() const { + // @@protoc_insertion_point(field_get:subspace.Discovery.port) + return _internal_port(); +} +inline void Discovery::set_port(::int32_t value) { + _internal_set_port(value); + // @@protoc_insertion_point(field_set:subspace.Discovery.port) +} +inline ::int32_t Discovery::_internal_port() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.port_; +} +inline void Discovery::_internal_set_port(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = value; +} + +// .subspace.Discovery.Query query = 3; +inline bool Discovery::has_query() const { + return data_case() == kQuery; +} +inline bool Discovery::_internal_has_query() const { + return data_case() == kQuery; +} +inline void Discovery::set_has_query() { + _impl_._oneof_case_[0] = kQuery; +} +inline void Discovery::clear_query() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (data_case() == kQuery) { + if (GetArena() == nullptr) { + delete _impl_.data_.query_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.data_.query_); + } + clear_has_data(); + } +} +inline ::subspace::Discovery_Query* Discovery::release_query() { + // @@protoc_insertion_point(field_release:subspace.Discovery.query) + if (data_case() == kQuery) { + clear_has_data(); + auto* temp = _impl_.data_.query_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.data_.query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::Discovery_Query& Discovery::_internal_query() const { + return data_case() == kQuery ? *_impl_.data_.query_ : reinterpret_cast<::subspace::Discovery_Query&>(::subspace::_Discovery_Query_default_instance_); +} +inline const ::subspace::Discovery_Query& Discovery::query() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.query) + return _internal_query(); +} +inline ::subspace::Discovery_Query* Discovery::unsafe_arena_release_query() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Discovery.query) + if (data_case() == kQuery) { + clear_has_data(); + auto* temp = _impl_.data_.query_; + _impl_.data_.query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Discovery::unsafe_arena_set_allocated_query(::subspace::Discovery_Query* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_data(); + if (value) { + set_has_query(); + _impl_.data_.query_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Discovery.query) +} +inline ::subspace::Discovery_Query* Discovery::_internal_mutable_query() { + if (data_case() != kQuery) { + clear_data(); + set_has_query(); + _impl_.data_.query_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::Discovery_Query>(GetArena()); + } + return _impl_.data_.query_; +} +inline ::subspace::Discovery_Query* Discovery::mutable_query() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::Discovery_Query* _msg = _internal_mutable_query(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.query) + return _msg; +} + +// .subspace.Discovery.Advertise advertise = 4; +inline bool Discovery::has_advertise() const { + return data_case() == kAdvertise; +} +inline bool Discovery::_internal_has_advertise() const { + return data_case() == kAdvertise; +} +inline void Discovery::set_has_advertise() { + _impl_._oneof_case_[0] = kAdvertise; +} +inline void Discovery::clear_advertise() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (data_case() == kAdvertise) { + if (GetArena() == nullptr) { + delete _impl_.data_.advertise_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.data_.advertise_); + } + clear_has_data(); + } +} +inline ::subspace::Discovery_Advertise* Discovery::release_advertise() { + // @@protoc_insertion_point(field_release:subspace.Discovery.advertise) + if (data_case() == kAdvertise) { + clear_has_data(); + auto* temp = _impl_.data_.advertise_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.data_.advertise_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::Discovery_Advertise& Discovery::_internal_advertise() const { + return data_case() == kAdvertise ? *_impl_.data_.advertise_ : reinterpret_cast<::subspace::Discovery_Advertise&>(::subspace::_Discovery_Advertise_default_instance_); +} +inline const ::subspace::Discovery_Advertise& Discovery::advertise() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.advertise) + return _internal_advertise(); +} +inline ::subspace::Discovery_Advertise* Discovery::unsafe_arena_release_advertise() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Discovery.advertise) + if (data_case() == kAdvertise) { + clear_has_data(); + auto* temp = _impl_.data_.advertise_; + _impl_.data_.advertise_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Discovery::unsafe_arena_set_allocated_advertise(::subspace::Discovery_Advertise* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_data(); + if (value) { + set_has_advertise(); + _impl_.data_.advertise_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Discovery.advertise) +} +inline ::subspace::Discovery_Advertise* Discovery::_internal_mutable_advertise() { + if (data_case() != kAdvertise) { + clear_data(); + set_has_advertise(); + _impl_.data_.advertise_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::Discovery_Advertise>(GetArena()); + } + return _impl_.data_.advertise_; +} +inline ::subspace::Discovery_Advertise* Discovery::mutable_advertise() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::Discovery_Advertise* _msg = _internal_mutable_advertise(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.advertise) + return _msg; +} + +// .subspace.Discovery.Subscribe subscribe = 5; +inline bool Discovery::has_subscribe() const { + return data_case() == kSubscribe; +} +inline bool Discovery::_internal_has_subscribe() const { + return data_case() == kSubscribe; +} +inline void Discovery::set_has_subscribe() { + _impl_._oneof_case_[0] = kSubscribe; +} +inline void Discovery::clear_subscribe() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (data_case() == kSubscribe) { + if (GetArena() == nullptr) { + delete _impl_.data_.subscribe_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.data_.subscribe_); + } + clear_has_data(); + } +} +inline ::subspace::Discovery_Subscribe* Discovery::release_subscribe() { + // @@protoc_insertion_point(field_release:subspace.Discovery.subscribe) + if (data_case() == kSubscribe) { + clear_has_data(); + auto* temp = _impl_.data_.subscribe_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.data_.subscribe_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::Discovery_Subscribe& Discovery::_internal_subscribe() const { + return data_case() == kSubscribe ? *_impl_.data_.subscribe_ : reinterpret_cast<::subspace::Discovery_Subscribe&>(::subspace::_Discovery_Subscribe_default_instance_); +} +inline const ::subspace::Discovery_Subscribe& Discovery::subscribe() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.Discovery.subscribe) + return _internal_subscribe(); +} +inline ::subspace::Discovery_Subscribe* Discovery::unsafe_arena_release_subscribe() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.Discovery.subscribe) + if (data_case() == kSubscribe) { + clear_has_data(); + auto* temp = _impl_.data_.subscribe_; + _impl_.data_.subscribe_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Discovery::unsafe_arena_set_allocated_subscribe(::subspace::Discovery_Subscribe* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_data(); + if (value) { + set_has_subscribe(); + _impl_.data_.subscribe_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.Discovery.subscribe) +} +inline ::subspace::Discovery_Subscribe* Discovery::_internal_mutable_subscribe() { + if (data_case() != kSubscribe) { + clear_data(); + set_has_subscribe(); + _impl_.data_.subscribe_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::Discovery_Subscribe>(GetArena()); + } + return _impl_.data_.subscribe_; +} +inline ::subspace::Discovery_Subscribe* Discovery::mutable_subscribe() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::Discovery_Subscribe* _msg = _internal_mutable_subscribe(); + // @@protoc_insertion_point(field_mutable:subspace.Discovery.subscribe) + return _msg; +} + +inline bool Discovery::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void Discovery::clear_has_data() { + _impl_._oneof_case_[0] = DATA_NOT_SET; +} +inline Discovery::DataCase Discovery::data_case() const { + return Discovery::DataCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// RpcOpenRequest + +// ------------------------------------------------------------------- + +// RpcOpenResponse_RequestChannel + +// string name = 1; +inline void RpcOpenResponse_RequestChannel::clear_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.ClearToEmpty(); +} +inline const std::string& RpcOpenResponse_RequestChannel::name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.RequestChannel.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcOpenResponse_RequestChannel::set_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.RequestChannel.name) +} +inline std::string* RpcOpenResponse_RequestChannel::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.RequestChannel.name) + return _s; +} +inline const std::string& RpcOpenResponse_RequestChannel::_internal_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.name_.Get(); +} +inline void RpcOpenResponse_RequestChannel::_internal_set_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(value, GetArena()); +} +inline std::string* RpcOpenResponse_RequestChannel::_internal_mutable_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.name_.Mutable( GetArena()); +} +inline std::string* RpcOpenResponse_RequestChannel::release_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.RequestChannel.name) + return _impl_.name_.Release(); +} +inline void RpcOpenResponse_RequestChannel::set_allocated_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.RequestChannel.name) +} + +// int32 slot_size = 2; +inline void RpcOpenResponse_RequestChannel::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t RpcOpenResponse_RequestChannel::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.RequestChannel.slot_size) + return _internal_slot_size(); +} +inline void RpcOpenResponse_RequestChannel::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.RequestChannel.slot_size) +} +inline ::int32_t RpcOpenResponse_RequestChannel::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void RpcOpenResponse_RequestChannel::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// int32 num_slots = 3; +inline void RpcOpenResponse_RequestChannel::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t RpcOpenResponse_RequestChannel::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.RequestChannel.num_slots) + return _internal_num_slots(); +} +inline void RpcOpenResponse_RequestChannel::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.RequestChannel.num_slots) +} +inline ::int32_t RpcOpenResponse_RequestChannel::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void RpcOpenResponse_RequestChannel::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// string type = 4; +inline void RpcOpenResponse_RequestChannel::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& RpcOpenResponse_RequestChannel::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.RequestChannel.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcOpenResponse_RequestChannel::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.RequestChannel.type) +} +inline std::string* RpcOpenResponse_RequestChannel::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.RequestChannel.type) + return _s; +} +inline const std::string& RpcOpenResponse_RequestChannel::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void RpcOpenResponse_RequestChannel::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* RpcOpenResponse_RequestChannel::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* RpcOpenResponse_RequestChannel::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.RequestChannel.type) + return _impl_.type_.Release(); +} +inline void RpcOpenResponse_RequestChannel::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.RequestChannel.type) +} + +// ------------------------------------------------------------------- + +// RpcOpenResponse_ResponseChannel + +// string name = 1; +inline void RpcOpenResponse_ResponseChannel::clear_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.ClearToEmpty(); +} +inline const std::string& RpcOpenResponse_ResponseChannel::name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.ResponseChannel.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcOpenResponse_ResponseChannel::set_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.ResponseChannel.name) +} +inline std::string* RpcOpenResponse_ResponseChannel::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.ResponseChannel.name) + return _s; +} +inline const std::string& RpcOpenResponse_ResponseChannel::_internal_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.name_.Get(); +} +inline void RpcOpenResponse_ResponseChannel::_internal_set_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(value, GetArena()); +} +inline std::string* RpcOpenResponse_ResponseChannel::_internal_mutable_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.name_.Mutable( GetArena()); +} +inline std::string* RpcOpenResponse_ResponseChannel::release_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.ResponseChannel.name) + return _impl_.name_.Release(); +} +inline void RpcOpenResponse_ResponseChannel::set_allocated_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.ResponseChannel.name) +} + +// string type = 2; +inline void RpcOpenResponse_ResponseChannel::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& RpcOpenResponse_ResponseChannel::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.ResponseChannel.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcOpenResponse_ResponseChannel::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.ResponseChannel.type) +} +inline std::string* RpcOpenResponse_ResponseChannel::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.ResponseChannel.type) + return _s; +} +inline const std::string& RpcOpenResponse_ResponseChannel::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void RpcOpenResponse_ResponseChannel::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* RpcOpenResponse_ResponseChannel::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* RpcOpenResponse_ResponseChannel::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.ResponseChannel.type) + return _impl_.type_.Release(); +} +inline void RpcOpenResponse_ResponseChannel::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.ResponseChannel.type) +} + +// ------------------------------------------------------------------- + +// RpcOpenResponse_Method + +// string name = 1; +inline void RpcOpenResponse_Method::clear_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.ClearToEmpty(); +} +inline const std::string& RpcOpenResponse_Method::name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.Method.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcOpenResponse_Method::set_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.Method.name) +} +inline std::string* RpcOpenResponse_Method::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.Method.name) + return _s; +} +inline const std::string& RpcOpenResponse_Method::_internal_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.name_.Get(); +} +inline void RpcOpenResponse_Method::_internal_set_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(value, GetArena()); +} +inline std::string* RpcOpenResponse_Method::_internal_mutable_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.name_.Mutable( GetArena()); +} +inline std::string* RpcOpenResponse_Method::release_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.Method.name) + return _impl_.name_.Release(); +} +inline void RpcOpenResponse_Method::set_allocated_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.Method.name) +} + +// int32 id = 2; +inline void RpcOpenResponse_Method::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0; +} +inline ::int32_t RpcOpenResponse_Method::id() const { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.Method.id) + return _internal_id(); +} +inline void RpcOpenResponse_Method::set_id(::int32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.Method.id) +} +inline ::int32_t RpcOpenResponse_Method::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void RpcOpenResponse_Method::_internal_set_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// .subspace.RpcOpenResponse.RequestChannel request_channel = 3; +inline bool RpcOpenResponse_Method::has_request_channel() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.request_channel_ != nullptr); + return value; +} +inline void RpcOpenResponse_Method::clear_request_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.request_channel_ != nullptr) _impl_.request_channel_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::subspace::RpcOpenResponse_RequestChannel& RpcOpenResponse_Method::_internal_request_channel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::subspace::RpcOpenResponse_RequestChannel* p = _impl_.request_channel_; + return p != nullptr ? *p : reinterpret_cast(::subspace::_RpcOpenResponse_RequestChannel_default_instance_); +} +inline const ::subspace::RpcOpenResponse_RequestChannel& RpcOpenResponse_Method::request_channel() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.Method.request_channel) + return _internal_request_channel(); +} +inline void RpcOpenResponse_Method::unsafe_arena_set_allocated_request_channel(::subspace::RpcOpenResponse_RequestChannel* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.request_channel_); + } + _impl_.request_channel_ = reinterpret_cast<::subspace::RpcOpenResponse_RequestChannel*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcOpenResponse.Method.request_channel) +} +inline ::subspace::RpcOpenResponse_RequestChannel* RpcOpenResponse_Method::release_request_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::RpcOpenResponse_RequestChannel* released = _impl_.request_channel_; + _impl_.request_channel_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::subspace::RpcOpenResponse_RequestChannel* RpcOpenResponse_Method::unsafe_arena_release_request_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.Method.request_channel) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::RpcOpenResponse_RequestChannel* temp = _impl_.request_channel_; + _impl_.request_channel_ = nullptr; + return temp; +} +inline ::subspace::RpcOpenResponse_RequestChannel* RpcOpenResponse_Method::_internal_mutable_request_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.request_channel_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::subspace::RpcOpenResponse_RequestChannel>(GetArena()); + _impl_.request_channel_ = reinterpret_cast<::subspace::RpcOpenResponse_RequestChannel*>(p); + } + return _impl_.request_channel_; +} +inline ::subspace::RpcOpenResponse_RequestChannel* RpcOpenResponse_Method::mutable_request_channel() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::subspace::RpcOpenResponse_RequestChannel* _msg = _internal_mutable_request_channel(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.Method.request_channel) + return _msg; +} +inline void RpcOpenResponse_Method::set_allocated_request_channel(::subspace::RpcOpenResponse_RequestChannel* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.request_channel_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.request_channel_ = reinterpret_cast<::subspace::RpcOpenResponse_RequestChannel*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.Method.request_channel) +} + +// .subspace.RpcOpenResponse.ResponseChannel response_channel = 4; +inline bool RpcOpenResponse_Method::has_response_channel() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.response_channel_ != nullptr); + return value; +} +inline void RpcOpenResponse_Method::clear_response_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.response_channel_ != nullptr) _impl_.response_channel_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::subspace::RpcOpenResponse_ResponseChannel& RpcOpenResponse_Method::_internal_response_channel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::subspace::RpcOpenResponse_ResponseChannel* p = _impl_.response_channel_; + return p != nullptr ? *p : reinterpret_cast(::subspace::_RpcOpenResponse_ResponseChannel_default_instance_); +} +inline const ::subspace::RpcOpenResponse_ResponseChannel& RpcOpenResponse_Method::response_channel() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.Method.response_channel) + return _internal_response_channel(); +} +inline void RpcOpenResponse_Method::unsafe_arena_set_allocated_response_channel(::subspace::RpcOpenResponse_ResponseChannel* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_channel_); + } + _impl_.response_channel_ = reinterpret_cast<::subspace::RpcOpenResponse_ResponseChannel*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcOpenResponse.Method.response_channel) +} +inline ::subspace::RpcOpenResponse_ResponseChannel* RpcOpenResponse_Method::release_response_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::subspace::RpcOpenResponse_ResponseChannel* released = _impl_.response_channel_; + _impl_.response_channel_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::subspace::RpcOpenResponse_ResponseChannel* RpcOpenResponse_Method::unsafe_arena_release_response_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.Method.response_channel) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::subspace::RpcOpenResponse_ResponseChannel* temp = _impl_.response_channel_; + _impl_.response_channel_ = nullptr; + return temp; +} +inline ::subspace::RpcOpenResponse_ResponseChannel* RpcOpenResponse_Method::_internal_mutable_response_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.response_channel_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::subspace::RpcOpenResponse_ResponseChannel>(GetArena()); + _impl_.response_channel_ = reinterpret_cast<::subspace::RpcOpenResponse_ResponseChannel*>(p); + } + return _impl_.response_channel_; +} +inline ::subspace::RpcOpenResponse_ResponseChannel* RpcOpenResponse_Method::mutable_response_channel() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000002u; + ::subspace::RpcOpenResponse_ResponseChannel* _msg = _internal_mutable_response_channel(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.Method.response_channel) + return _msg; +} +inline void RpcOpenResponse_Method::set_allocated_response_channel(::subspace::RpcOpenResponse_ResponseChannel* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.response_channel_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.response_channel_ = reinterpret_cast<::subspace::RpcOpenResponse_ResponseChannel*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.Method.response_channel) +} + +// string cancel_channel = 5; +inline void RpcOpenResponse_Method::clear_cancel_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cancel_channel_.ClearToEmpty(); +} +inline const std::string& RpcOpenResponse_Method::cancel_channel() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.Method.cancel_channel) + return _internal_cancel_channel(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcOpenResponse_Method::set_cancel_channel(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cancel_channel_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.Method.cancel_channel) +} +inline std::string* RpcOpenResponse_Method::mutable_cancel_channel() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_cancel_channel(); + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.Method.cancel_channel) + return _s; +} +inline const std::string& RpcOpenResponse_Method::_internal_cancel_channel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.cancel_channel_.Get(); +} +inline void RpcOpenResponse_Method::_internal_set_cancel_channel(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cancel_channel_.Set(value, GetArena()); +} +inline std::string* RpcOpenResponse_Method::_internal_mutable_cancel_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.cancel_channel_.Mutable( GetArena()); +} +inline std::string* RpcOpenResponse_Method::release_cancel_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcOpenResponse.Method.cancel_channel) + return _impl_.cancel_channel_.Release(); +} +inline void RpcOpenResponse_Method::set_allocated_cancel_channel(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cancel_channel_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.cancel_channel_.IsDefault()) { + _impl_.cancel_channel_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcOpenResponse.Method.cancel_channel) +} + +// ------------------------------------------------------------------- + +// RpcOpenResponse + +// int32 session_id = 1; +inline void RpcOpenResponse::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = 0; +} +inline ::int32_t RpcOpenResponse::session_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.session_id) + return _internal_session_id(); +} +inline void RpcOpenResponse::set_session_id(::int32_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.session_id) +} +inline ::int32_t RpcOpenResponse::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void RpcOpenResponse::_internal_set_session_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// repeated .subspace.RpcOpenResponse.Method methods = 2; +inline int RpcOpenResponse::_internal_methods_size() const { + return _internal_methods().size(); +} +inline int RpcOpenResponse::methods_size() const { + return _internal_methods_size(); +} +inline void RpcOpenResponse::clear_methods() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.methods_.Clear(); +} +inline ::subspace::RpcOpenResponse_Method* RpcOpenResponse::mutable_methods(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:subspace.RpcOpenResponse.methods) + return _internal_mutable_methods()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>* RpcOpenResponse::mutable_methods() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:subspace.RpcOpenResponse.methods) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_methods(); +} +inline const ::subspace::RpcOpenResponse_Method& RpcOpenResponse::methods(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.methods) + return _internal_methods().Get(index); +} +inline ::subspace::RpcOpenResponse_Method* RpcOpenResponse::add_methods() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::subspace::RpcOpenResponse_Method* _add = _internal_mutable_methods()->Add(); + // @@protoc_insertion_point(field_add:subspace.RpcOpenResponse.methods) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>& RpcOpenResponse::methods() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:subspace.RpcOpenResponse.methods) + return _internal_methods(); +} +inline const ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>& +RpcOpenResponse::_internal_methods() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.methods_; +} +inline ::google::protobuf::RepeatedPtrField<::subspace::RpcOpenResponse_Method>* +RpcOpenResponse::_internal_mutable_methods() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.methods_; +} + +// uint64 client_id = 3; +inline void RpcOpenResponse::clear_client_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = ::uint64_t{0u}; +} +inline ::uint64_t RpcOpenResponse::client_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcOpenResponse.client_id) + return _internal_client_id(); +} +inline void RpcOpenResponse::set_client_id(::uint64_t value) { + _internal_set_client_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcOpenResponse.client_id) +} +inline ::uint64_t RpcOpenResponse::_internal_client_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_id_; +} +inline void RpcOpenResponse::_internal_set_client_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = value; +} + +// ------------------------------------------------------------------- + +// RpcCloseRequest + +// int32 session_id = 1; +inline void RpcCloseRequest::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = 0; +} +inline ::int32_t RpcCloseRequest::session_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcCloseRequest.session_id) + return _internal_session_id(); +} +inline void RpcCloseRequest::set_session_id(::int32_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcCloseRequest.session_id) +} +inline ::int32_t RpcCloseRequest::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void RpcCloseRequest::_internal_set_session_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// ------------------------------------------------------------------- + +// RpcCloseResponse + +// ------------------------------------------------------------------- + +// RpcServerRequest + +// uint64 client_id = 1; +inline void RpcServerRequest::clear_client_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = ::uint64_t{0u}; +} +inline ::uint64_t RpcServerRequest::client_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcServerRequest.client_id) + return _internal_client_id(); +} +inline void RpcServerRequest::set_client_id(::uint64_t value) { + _internal_set_client_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcServerRequest.client_id) +} +inline ::uint64_t RpcServerRequest::_internal_client_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_id_; +} +inline void RpcServerRequest::_internal_set_client_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = value; +} + +// int32 request_id = 2; +inline void RpcServerRequest::clear_request_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = 0; +} +inline ::int32_t RpcServerRequest::request_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcServerRequest.request_id) + return _internal_request_id(); +} +inline void RpcServerRequest::set_request_id(::int32_t value) { + _internal_set_request_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcServerRequest.request_id) +} +inline ::int32_t RpcServerRequest::_internal_request_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.request_id_; +} +inline void RpcServerRequest::_internal_set_request_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = value; +} + +// .subspace.RpcOpenRequest open = 3; +inline bool RpcServerRequest::has_open() const { + return request_case() == kOpen; +} +inline bool RpcServerRequest::_internal_has_open() const { + return request_case() == kOpen; +} +inline void RpcServerRequest::set_has_open() { + _impl_._oneof_case_[0] = kOpen; +} +inline void RpcServerRequest::clear_open() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kOpen) { + if (GetArena() == nullptr) { + delete _impl_.request_.open_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.open_); + } + clear_has_request(); + } +} +inline ::subspace::RpcOpenRequest* RpcServerRequest::release_open() { + // @@protoc_insertion_point(field_release:subspace.RpcServerRequest.open) + if (request_case() == kOpen) { + clear_has_request(); + auto* temp = _impl_.request_.open_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.open_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RpcOpenRequest& RpcServerRequest::_internal_open() const { + return request_case() == kOpen ? *_impl_.request_.open_ : reinterpret_cast<::subspace::RpcOpenRequest&>(::subspace::_RpcOpenRequest_default_instance_); +} +inline const ::subspace::RpcOpenRequest& RpcServerRequest::open() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcServerRequest.open) + return _internal_open(); +} +inline ::subspace::RpcOpenRequest* RpcServerRequest::unsafe_arena_release_open() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.RpcServerRequest.open) + if (request_case() == kOpen) { + clear_has_request(); + auto* temp = _impl_.request_.open_; + _impl_.request_.open_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RpcServerRequest::unsafe_arena_set_allocated_open(::subspace::RpcOpenRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_open(); + _impl_.request_.open_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcServerRequest.open) +} +inline ::subspace::RpcOpenRequest* RpcServerRequest::_internal_mutable_open() { + if (request_case() != kOpen) { + clear_request(); + set_has_open(); + _impl_.request_.open_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RpcOpenRequest>(GetArena()); + } + return _impl_.request_.open_; +} +inline ::subspace::RpcOpenRequest* RpcServerRequest::mutable_open() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RpcOpenRequest* _msg = _internal_mutable_open(); + // @@protoc_insertion_point(field_mutable:subspace.RpcServerRequest.open) + return _msg; +} + +// .subspace.RpcCloseRequest close = 4; +inline bool RpcServerRequest::has_close() const { + return request_case() == kClose; +} +inline bool RpcServerRequest::_internal_has_close() const { + return request_case() == kClose; +} +inline void RpcServerRequest::set_has_close() { + _impl_._oneof_case_[0] = kClose; +} +inline void RpcServerRequest::clear_close() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (request_case() == kClose) { + if (GetArena() == nullptr) { + delete _impl_.request_.close_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.request_.close_); + } + clear_has_request(); + } +} +inline ::subspace::RpcCloseRequest* RpcServerRequest::release_close() { + // @@protoc_insertion_point(field_release:subspace.RpcServerRequest.close) + if (request_case() == kClose) { + clear_has_request(); + auto* temp = _impl_.request_.close_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.request_.close_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RpcCloseRequest& RpcServerRequest::_internal_close() const { + return request_case() == kClose ? *_impl_.request_.close_ : reinterpret_cast<::subspace::RpcCloseRequest&>(::subspace::_RpcCloseRequest_default_instance_); +} +inline const ::subspace::RpcCloseRequest& RpcServerRequest::close() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcServerRequest.close) + return _internal_close(); +} +inline ::subspace::RpcCloseRequest* RpcServerRequest::unsafe_arena_release_close() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.RpcServerRequest.close) + if (request_case() == kClose) { + clear_has_request(); + auto* temp = _impl_.request_.close_; + _impl_.request_.close_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RpcServerRequest::unsafe_arena_set_allocated_close(::subspace::RpcCloseRequest* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_request(); + if (value) { + set_has_close(); + _impl_.request_.close_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcServerRequest.close) +} +inline ::subspace::RpcCloseRequest* RpcServerRequest::_internal_mutable_close() { + if (request_case() != kClose) { + clear_request(); + set_has_close(); + _impl_.request_.close_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RpcCloseRequest>(GetArena()); + } + return _impl_.request_.close_; +} +inline ::subspace::RpcCloseRequest* RpcServerRequest::mutable_close() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RpcCloseRequest* _msg = _internal_mutable_close(); + // @@protoc_insertion_point(field_mutable:subspace.RpcServerRequest.close) + return _msg; +} + +inline bool RpcServerRequest::has_request() const { + return request_case() != REQUEST_NOT_SET; +} +inline void RpcServerRequest::clear_has_request() { + _impl_._oneof_case_[0] = REQUEST_NOT_SET; +} +inline RpcServerRequest::RequestCase RpcServerRequest::request_case() const { + return RpcServerRequest::RequestCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// RpcServerResponse + +// uint64 client_id = 1; +inline void RpcServerResponse::clear_client_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = ::uint64_t{0u}; +} +inline ::uint64_t RpcServerResponse::client_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcServerResponse.client_id) + return _internal_client_id(); +} +inline void RpcServerResponse::set_client_id(::uint64_t value) { + _internal_set_client_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcServerResponse.client_id) +} +inline ::uint64_t RpcServerResponse::_internal_client_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_id_; +} +inline void RpcServerResponse::_internal_set_client_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = value; +} + +// int32 request_id = 2; +inline void RpcServerResponse::clear_request_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = 0; +} +inline ::int32_t RpcServerResponse::request_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcServerResponse.request_id) + return _internal_request_id(); +} +inline void RpcServerResponse::set_request_id(::int32_t value) { + _internal_set_request_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcServerResponse.request_id) +} +inline ::int32_t RpcServerResponse::_internal_request_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.request_id_; +} +inline void RpcServerResponse::_internal_set_request_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = value; +} + +// .subspace.RpcOpenResponse open = 3; +inline bool RpcServerResponse::has_open() const { + return response_case() == kOpen; +} +inline bool RpcServerResponse::_internal_has_open() const { + return response_case() == kOpen; +} +inline void RpcServerResponse::set_has_open() { + _impl_._oneof_case_[0] = kOpen; +} +inline void RpcServerResponse::clear_open() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kOpen) { + if (GetArena() == nullptr) { + delete _impl_.response_.open_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.open_); + } + clear_has_response(); + } +} +inline ::subspace::RpcOpenResponse* RpcServerResponse::release_open() { + // @@protoc_insertion_point(field_release:subspace.RpcServerResponse.open) + if (response_case() == kOpen) { + clear_has_response(); + auto* temp = _impl_.response_.open_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.open_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RpcOpenResponse& RpcServerResponse::_internal_open() const { + return response_case() == kOpen ? *_impl_.response_.open_ : reinterpret_cast<::subspace::RpcOpenResponse&>(::subspace::_RpcOpenResponse_default_instance_); +} +inline const ::subspace::RpcOpenResponse& RpcServerResponse::open() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcServerResponse.open) + return _internal_open(); +} +inline ::subspace::RpcOpenResponse* RpcServerResponse::unsafe_arena_release_open() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.RpcServerResponse.open) + if (response_case() == kOpen) { + clear_has_response(); + auto* temp = _impl_.response_.open_; + _impl_.response_.open_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RpcServerResponse::unsafe_arena_set_allocated_open(::subspace::RpcOpenResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_open(); + _impl_.response_.open_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcServerResponse.open) +} +inline ::subspace::RpcOpenResponse* RpcServerResponse::_internal_mutable_open() { + if (response_case() != kOpen) { + clear_response(); + set_has_open(); + _impl_.response_.open_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RpcOpenResponse>(GetArena()); + } + return _impl_.response_.open_; +} +inline ::subspace::RpcOpenResponse* RpcServerResponse::mutable_open() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RpcOpenResponse* _msg = _internal_mutable_open(); + // @@protoc_insertion_point(field_mutable:subspace.RpcServerResponse.open) + return _msg; +} + +// .subspace.RpcCloseResponse close = 4; +inline bool RpcServerResponse::has_close() const { + return response_case() == kClose; +} +inline bool RpcServerResponse::_internal_has_close() const { + return response_case() == kClose; +} +inline void RpcServerResponse::set_has_close() { + _impl_._oneof_case_[0] = kClose; +} +inline void RpcServerResponse::clear_close() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (response_case() == kClose) { + if (GetArena() == nullptr) { + delete _impl_.response_.close_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.response_.close_); + } + clear_has_response(); + } +} +inline ::subspace::RpcCloseResponse* RpcServerResponse::release_close() { + // @@protoc_insertion_point(field_release:subspace.RpcServerResponse.close) + if (response_case() == kClose) { + clear_has_response(); + auto* temp = _impl_.response_.close_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.response_.close_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::RpcCloseResponse& RpcServerResponse::_internal_close() const { + return response_case() == kClose ? *_impl_.response_.close_ : reinterpret_cast<::subspace::RpcCloseResponse&>(::subspace::_RpcCloseResponse_default_instance_); +} +inline const ::subspace::RpcCloseResponse& RpcServerResponse::close() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcServerResponse.close) + return _internal_close(); +} +inline ::subspace::RpcCloseResponse* RpcServerResponse::unsafe_arena_release_close() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.RpcServerResponse.close) + if (response_case() == kClose) { + clear_has_response(); + auto* temp = _impl_.response_.close_; + _impl_.response_.close_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RpcServerResponse::unsafe_arena_set_allocated_close(::subspace::RpcCloseResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_response(); + if (value) { + set_has_close(); + _impl_.response_.close_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcServerResponse.close) +} +inline ::subspace::RpcCloseResponse* RpcServerResponse::_internal_mutable_close() { + if (response_case() != kClose) { + clear_response(); + set_has_close(); + _impl_.response_.close_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::RpcCloseResponse>(GetArena()); + } + return _impl_.response_.close_; +} +inline ::subspace::RpcCloseResponse* RpcServerResponse::mutable_close() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::RpcCloseResponse* _msg = _internal_mutable_close(); + // @@protoc_insertion_point(field_mutable:subspace.RpcServerResponse.close) + return _msg; +} + +// string error = 5; +inline void RpcServerResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& RpcServerResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcServerResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcServerResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcServerResponse.error) +} +inline std::string* RpcServerResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.RpcServerResponse.error) + return _s; +} +inline const std::string& RpcServerResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void RpcServerResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* RpcServerResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* RpcServerResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcServerResponse.error) + return _impl_.error_.Release(); +} +inline void RpcServerResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcServerResponse.error) +} + +inline bool RpcServerResponse::has_response() const { + return response_case() != RESPONSE_NOT_SET; +} +inline void RpcServerResponse::clear_has_response() { + _impl_._oneof_case_[0] = RESPONSE_NOT_SET; +} +inline RpcServerResponse::ResponseCase RpcServerResponse::response_case() const { + return RpcServerResponse::ResponseCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// RpcRequest + +// int32 method = 1; +inline void RpcRequest::clear_method() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.method_ = 0; +} +inline ::int32_t RpcRequest::method() const { + // @@protoc_insertion_point(field_get:subspace.RpcRequest.method) + return _internal_method(); +} +inline void RpcRequest::set_method(::int32_t value) { + _internal_set_method(value); + // @@protoc_insertion_point(field_set:subspace.RpcRequest.method) +} +inline ::int32_t RpcRequest::_internal_method() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.method_; +} +inline void RpcRequest::_internal_set_method(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.method_ = value; +} + +// .google.protobuf.Any argument = 2; +inline bool RpcRequest::has_argument() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.argument_ != nullptr); + return value; +} +inline const ::google::protobuf::Any& RpcRequest::_internal_argument() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::google::protobuf::Any* p = _impl_.argument_; + return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); +} +inline const ::google::protobuf::Any& RpcRequest::argument() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcRequest.argument) + return _internal_argument(); +} +inline void RpcRequest::unsafe_arena_set_allocated_argument(::google::protobuf::Any* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.argument_); + } + _impl_.argument_ = reinterpret_cast<::google::protobuf::Any*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcRequest.argument) +} +inline ::google::protobuf::Any* RpcRequest::release_argument() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* released = _impl_.argument_; + _impl_.argument_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::google::protobuf::Any* RpcRequest::unsafe_arena_release_argument() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcRequest.argument) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* temp = _impl_.argument_; + _impl_.argument_ = nullptr; + return temp; +} +inline ::google::protobuf::Any* RpcRequest::_internal_mutable_argument() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.argument_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); + _impl_.argument_ = reinterpret_cast<::google::protobuf::Any*>(p); + } + return _impl_.argument_; +} +inline ::google::protobuf::Any* RpcRequest::mutable_argument() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::google::protobuf::Any* _msg = _internal_mutable_argument(); + // @@protoc_insertion_point(field_mutable:subspace.RpcRequest.argument) + return _msg; +} +inline void RpcRequest::set_allocated_argument(::google::protobuf::Any* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.argument_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.argument_ = reinterpret_cast<::google::protobuf::Any*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.RpcRequest.argument) +} + +// int32 session_id = 3; +inline void RpcRequest::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = 0; +} +inline ::int32_t RpcRequest::session_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcRequest.session_id) + return _internal_session_id(); +} +inline void RpcRequest::set_session_id(::int32_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcRequest.session_id) +} +inline ::int32_t RpcRequest::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void RpcRequest::_internal_set_session_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// int32 request_id = 4; +inline void RpcRequest::clear_request_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = 0; +} +inline ::int32_t RpcRequest::request_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcRequest.request_id) + return _internal_request_id(); +} +inline void RpcRequest::set_request_id(::int32_t value) { + _internal_set_request_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcRequest.request_id) +} +inline ::int32_t RpcRequest::_internal_request_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.request_id_; +} +inline void RpcRequest::_internal_set_request_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = value; +} + +// uint64 client_id = 5; +inline void RpcRequest::clear_client_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = ::uint64_t{0u}; +} +inline ::uint64_t RpcRequest::client_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcRequest.client_id) + return _internal_client_id(); +} +inline void RpcRequest::set_client_id(::uint64_t value) { + _internal_set_client_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcRequest.client_id) +} +inline ::uint64_t RpcRequest::_internal_client_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_id_; +} +inline void RpcRequest::_internal_set_client_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = value; +} + +// ------------------------------------------------------------------- + +// RpcResponse + +// string error = 1; +inline void RpcResponse::clear_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.ClearToEmpty(); +} +inline const std::string& RpcResponse::error() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.error) + return _internal_error(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RpcResponse::set_error(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RpcResponse.error) +} +inline std::string* RpcResponse::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:subspace.RpcResponse.error) + return _s; +} +inline const std::string& RpcResponse::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.error_.Get(); +} +inline void RpcResponse::_internal_set_error(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.Set(value, GetArena()); +} +inline std::string* RpcResponse::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.error_.Mutable( GetArena()); +} +inline std::string* RpcResponse::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcResponse.error) + return _impl_.error_.Release(); +} +inline void RpcResponse::set_allocated_error(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RpcResponse.error) +} + +// .google.protobuf.Any result = 2; +inline bool RpcResponse::has_result() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.result_ != nullptr); + return value; +} +inline const ::google::protobuf::Any& RpcResponse::_internal_result() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::google::protobuf::Any* p = _impl_.result_; + return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); +} +inline const ::google::protobuf::Any& RpcResponse::result() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.result) + return _internal_result(); +} +inline void RpcResponse::unsafe_arena_set_allocated_result(::google::protobuf::Any* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.result_); + } + _impl_.result_ = reinterpret_cast<::google::protobuf::Any*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.RpcResponse.result) +} +inline ::google::protobuf::Any* RpcResponse::release_result() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* released = _impl_.result_; + _impl_.result_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::google::protobuf::Any* RpcResponse::unsafe_arena_release_result() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RpcResponse.result) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::google::protobuf::Any* temp = _impl_.result_; + _impl_.result_ = nullptr; + return temp; +} +inline ::google::protobuf::Any* RpcResponse::_internal_mutable_result() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.result_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); + _impl_.result_ = reinterpret_cast<::google::protobuf::Any*>(p); + } + return _impl_.result_; +} +inline ::google::protobuf::Any* RpcResponse::mutable_result() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::google::protobuf::Any* _msg = _internal_mutable_result(); + // @@protoc_insertion_point(field_mutable:subspace.RpcResponse.result) + return _msg; +} +inline void RpcResponse::set_allocated_result(::google::protobuf::Any* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.result_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.result_ = reinterpret_cast<::google::protobuf::Any*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.RpcResponse.result) +} + +// int32 session_id = 3; +inline void RpcResponse::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = 0; +} +inline ::int32_t RpcResponse::session_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.session_id) + return _internal_session_id(); +} +inline void RpcResponse::set_session_id(::int32_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcResponse.session_id) +} +inline ::int32_t RpcResponse::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void RpcResponse::_internal_set_session_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// int32 request_id = 4; +inline void RpcResponse::clear_request_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = 0; +} +inline ::int32_t RpcResponse::request_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.request_id) + return _internal_request_id(); +} +inline void RpcResponse::set_request_id(::int32_t value) { + _internal_set_request_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcResponse.request_id) +} +inline ::int32_t RpcResponse::_internal_request_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.request_id_; +} +inline void RpcResponse::_internal_set_request_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = value; +} + +// uint64 client_id = 5; +inline void RpcResponse::clear_client_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = ::uint64_t{0u}; +} +inline ::uint64_t RpcResponse::client_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.client_id) + return _internal_client_id(); +} +inline void RpcResponse::set_client_id(::uint64_t value) { + _internal_set_client_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcResponse.client_id) +} +inline ::uint64_t RpcResponse::_internal_client_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_id_; +} +inline void RpcResponse::_internal_set_client_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = value; +} + +// bool is_last = 6; +inline void RpcResponse::clear_is_last() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_last_ = false; +} +inline bool RpcResponse::is_last() const { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.is_last) + return _internal_is_last(); +} +inline void RpcResponse::set_is_last(bool value) { + _internal_set_is_last(value); + // @@protoc_insertion_point(field_set:subspace.RpcResponse.is_last) +} +inline bool RpcResponse::_internal_is_last() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_last_; +} +inline void RpcResponse::_internal_set_is_last(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_last_ = value; +} + +// bool is_cancelled = 7; +inline void RpcResponse::clear_is_cancelled() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_cancelled_ = false; +} +inline bool RpcResponse::is_cancelled() const { + // @@protoc_insertion_point(field_get:subspace.RpcResponse.is_cancelled) + return _internal_is_cancelled(); +} +inline void RpcResponse::set_is_cancelled(bool value) { + _internal_set_is_cancelled(value); + // @@protoc_insertion_point(field_set:subspace.RpcResponse.is_cancelled) +} +inline bool RpcResponse::_internal_is_cancelled() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_cancelled_; +} +inline void RpcResponse::_internal_set_is_cancelled(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_cancelled_ = value; +} + +// ------------------------------------------------------------------- + +// RpcCancelRequest + +// int32 session_id = 1; +inline void RpcCancelRequest::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = 0; +} +inline ::int32_t RpcCancelRequest::session_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcCancelRequest.session_id) + return _internal_session_id(); +} +inline void RpcCancelRequest::set_session_id(::int32_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcCancelRequest.session_id) +} +inline ::int32_t RpcCancelRequest::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void RpcCancelRequest::_internal_set_session_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// int32 request_id = 2; +inline void RpcCancelRequest::clear_request_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = 0; +} +inline ::int32_t RpcCancelRequest::request_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcCancelRequest.request_id) + return _internal_request_id(); +} +inline void RpcCancelRequest::set_request_id(::int32_t value) { + _internal_set_request_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcCancelRequest.request_id) +} +inline ::int32_t RpcCancelRequest::_internal_request_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.request_id_; +} +inline void RpcCancelRequest::_internal_set_request_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.request_id_ = value; +} + +// uint64 client_id = 3; +inline void RpcCancelRequest::clear_client_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = ::uint64_t{0u}; +} +inline ::uint64_t RpcCancelRequest::client_id() const { + // @@protoc_insertion_point(field_get:subspace.RpcCancelRequest.client_id) + return _internal_client_id(); +} +inline void RpcCancelRequest::set_client_id(::uint64_t value) { + _internal_set_client_id(value); + // @@protoc_insertion_point(field_set:subspace.RpcCancelRequest.client_id) +} +inline ::uint64_t RpcCancelRequest::_internal_client_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.client_id_; +} +inline void RpcCancelRequest::_internal_set_client_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.client_id_ = value; +} + +// ------------------------------------------------------------------- + +// RawMessage + +// bytes data = 1; +inline void RawMessage::clear_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.data_.ClearToEmpty(); +} +inline const std::string& RawMessage::data() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.RawMessage.data) + return _internal_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RawMessage::set_data(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.RawMessage.data) +} +inline std::string* RawMessage::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_data(); + // @@protoc_insertion_point(field_mutable:subspace.RawMessage.data) + return _s; +} +inline const std::string& RawMessage::_internal_data() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.data_.Get(); +} +inline void RawMessage::_internal_set_data(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.data_.Set(value, GetArena()); +} +inline std::string* RawMessage::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.data_.Mutable( GetArena()); +} +inline std::string* RawMessage::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.RawMessage.data) + return _impl_.data_.Release(); +} +inline void RawMessage::set_allocated_data(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.data_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.data_.IsDefault()) { + _impl_.data_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.RawMessage.data) +} + +// ------------------------------------------------------------------- + +// VoidMessage + +// ------------------------------------------------------------------- + +// ShadowEvent + +// .subspace.ShadowInit init = 1; +inline bool ShadowEvent::has_init() const { + return event_case() == kInit; +} +inline bool ShadowEvent::_internal_has_init() const { + return event_case() == kInit; +} +inline void ShadowEvent::set_has_init() { + _impl_._oneof_case_[0] = kInit; +} +inline void ShadowEvent::clear_init() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kInit) { + if (GetArena() == nullptr) { + delete _impl_.event_.init_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.init_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowInit* ShadowEvent::release_init() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.init) + if (event_case() == kInit) { + clear_has_event(); + auto* temp = _impl_.event_.init_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.init_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowInit& ShadowEvent::_internal_init() const { + return event_case() == kInit ? *_impl_.event_.init_ : reinterpret_cast<::subspace::ShadowInit&>(::subspace::_ShadowInit_default_instance_); +} +inline const ::subspace::ShadowInit& ShadowEvent::init() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.init) + return _internal_init(); +} +inline ::subspace::ShadowInit* ShadowEvent::unsafe_arena_release_init() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.init) + if (event_case() == kInit) { + clear_has_event(); + auto* temp = _impl_.event_.init_; + _impl_.event_.init_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_init(::subspace::ShadowInit* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_init(); + _impl_.event_.init_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.init) +} +inline ::subspace::ShadowInit* ShadowEvent::_internal_mutable_init() { + if (event_case() != kInit) { + clear_event(); + set_has_init(); + _impl_.event_.init_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowInit>(GetArena()); + } + return _impl_.event_.init_; +} +inline ::subspace::ShadowInit* ShadowEvent::mutable_init() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowInit* _msg = _internal_mutable_init(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.init) + return _msg; +} + +// .subspace.ShadowCreateChannel create_channel = 2; +inline bool ShadowEvent::has_create_channel() const { + return event_case() == kCreateChannel; +} +inline bool ShadowEvent::_internal_has_create_channel() const { + return event_case() == kCreateChannel; +} +inline void ShadowEvent::set_has_create_channel() { + _impl_._oneof_case_[0] = kCreateChannel; +} +inline void ShadowEvent::clear_create_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kCreateChannel) { + if (GetArena() == nullptr) { + delete _impl_.event_.create_channel_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.create_channel_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowCreateChannel* ShadowEvent::release_create_channel() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.create_channel) + if (event_case() == kCreateChannel) { + clear_has_event(); + auto* temp = _impl_.event_.create_channel_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.create_channel_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowCreateChannel& ShadowEvent::_internal_create_channel() const { + return event_case() == kCreateChannel ? *_impl_.event_.create_channel_ : reinterpret_cast<::subspace::ShadowCreateChannel&>(::subspace::_ShadowCreateChannel_default_instance_); +} +inline const ::subspace::ShadowCreateChannel& ShadowEvent::create_channel() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.create_channel) + return _internal_create_channel(); +} +inline ::subspace::ShadowCreateChannel* ShadowEvent::unsafe_arena_release_create_channel() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.create_channel) + if (event_case() == kCreateChannel) { + clear_has_event(); + auto* temp = _impl_.event_.create_channel_; + _impl_.event_.create_channel_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_create_channel(::subspace::ShadowCreateChannel* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_create_channel(); + _impl_.event_.create_channel_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.create_channel) +} +inline ::subspace::ShadowCreateChannel* ShadowEvent::_internal_mutable_create_channel() { + if (event_case() != kCreateChannel) { + clear_event(); + set_has_create_channel(); + _impl_.event_.create_channel_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowCreateChannel>(GetArena()); + } + return _impl_.event_.create_channel_; +} +inline ::subspace::ShadowCreateChannel* ShadowEvent::mutable_create_channel() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowCreateChannel* _msg = _internal_mutable_create_channel(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.create_channel) + return _msg; +} + +// .subspace.ShadowRemoveChannel remove_channel = 3; +inline bool ShadowEvent::has_remove_channel() const { + return event_case() == kRemoveChannel; +} +inline bool ShadowEvent::_internal_has_remove_channel() const { + return event_case() == kRemoveChannel; +} +inline void ShadowEvent::set_has_remove_channel() { + _impl_._oneof_case_[0] = kRemoveChannel; +} +inline void ShadowEvent::clear_remove_channel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kRemoveChannel) { + if (GetArena() == nullptr) { + delete _impl_.event_.remove_channel_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.remove_channel_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowRemoveChannel* ShadowEvent::release_remove_channel() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.remove_channel) + if (event_case() == kRemoveChannel) { + clear_has_event(); + auto* temp = _impl_.event_.remove_channel_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.remove_channel_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowRemoveChannel& ShadowEvent::_internal_remove_channel() const { + return event_case() == kRemoveChannel ? *_impl_.event_.remove_channel_ : reinterpret_cast<::subspace::ShadowRemoveChannel&>(::subspace::_ShadowRemoveChannel_default_instance_); +} +inline const ::subspace::ShadowRemoveChannel& ShadowEvent::remove_channel() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.remove_channel) + return _internal_remove_channel(); +} +inline ::subspace::ShadowRemoveChannel* ShadowEvent::unsafe_arena_release_remove_channel() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.remove_channel) + if (event_case() == kRemoveChannel) { + clear_has_event(); + auto* temp = _impl_.event_.remove_channel_; + _impl_.event_.remove_channel_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_remove_channel(::subspace::ShadowRemoveChannel* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_remove_channel(); + _impl_.event_.remove_channel_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.remove_channel) +} +inline ::subspace::ShadowRemoveChannel* ShadowEvent::_internal_mutable_remove_channel() { + if (event_case() != kRemoveChannel) { + clear_event(); + set_has_remove_channel(); + _impl_.event_.remove_channel_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowRemoveChannel>(GetArena()); + } + return _impl_.event_.remove_channel_; +} +inline ::subspace::ShadowRemoveChannel* ShadowEvent::mutable_remove_channel() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowRemoveChannel* _msg = _internal_mutable_remove_channel(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.remove_channel) + return _msg; +} + +// .subspace.ShadowAddPublisher add_publisher = 4; +inline bool ShadowEvent::has_add_publisher() const { + return event_case() == kAddPublisher; +} +inline bool ShadowEvent::_internal_has_add_publisher() const { + return event_case() == kAddPublisher; +} +inline void ShadowEvent::set_has_add_publisher() { + _impl_._oneof_case_[0] = kAddPublisher; +} +inline void ShadowEvent::clear_add_publisher() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kAddPublisher) { + if (GetArena() == nullptr) { + delete _impl_.event_.add_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.add_publisher_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowAddPublisher* ShadowEvent::release_add_publisher() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.add_publisher) + if (event_case() == kAddPublisher) { + clear_has_event(); + auto* temp = _impl_.event_.add_publisher_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.add_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowAddPublisher& ShadowEvent::_internal_add_publisher() const { + return event_case() == kAddPublisher ? *_impl_.event_.add_publisher_ : reinterpret_cast<::subspace::ShadowAddPublisher&>(::subspace::_ShadowAddPublisher_default_instance_); +} +inline const ::subspace::ShadowAddPublisher& ShadowEvent::add_publisher() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.add_publisher) + return _internal_add_publisher(); +} +inline ::subspace::ShadowAddPublisher* ShadowEvent::unsafe_arena_release_add_publisher() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.add_publisher) + if (event_case() == kAddPublisher) { + clear_has_event(); + auto* temp = _impl_.event_.add_publisher_; + _impl_.event_.add_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_add_publisher(::subspace::ShadowAddPublisher* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_add_publisher(); + _impl_.event_.add_publisher_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.add_publisher) +} +inline ::subspace::ShadowAddPublisher* ShadowEvent::_internal_mutable_add_publisher() { + if (event_case() != kAddPublisher) { + clear_event(); + set_has_add_publisher(); + _impl_.event_.add_publisher_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowAddPublisher>(GetArena()); + } + return _impl_.event_.add_publisher_; +} +inline ::subspace::ShadowAddPublisher* ShadowEvent::mutable_add_publisher() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowAddPublisher* _msg = _internal_mutable_add_publisher(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.add_publisher) + return _msg; +} + +// .subspace.ShadowRemovePublisher remove_publisher = 5; +inline bool ShadowEvent::has_remove_publisher() const { + return event_case() == kRemovePublisher; +} +inline bool ShadowEvent::_internal_has_remove_publisher() const { + return event_case() == kRemovePublisher; +} +inline void ShadowEvent::set_has_remove_publisher() { + _impl_._oneof_case_[0] = kRemovePublisher; +} +inline void ShadowEvent::clear_remove_publisher() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kRemovePublisher) { + if (GetArena() == nullptr) { + delete _impl_.event_.remove_publisher_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.remove_publisher_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowRemovePublisher* ShadowEvent::release_remove_publisher() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.remove_publisher) + if (event_case() == kRemovePublisher) { + clear_has_event(); + auto* temp = _impl_.event_.remove_publisher_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.remove_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowRemovePublisher& ShadowEvent::_internal_remove_publisher() const { + return event_case() == kRemovePublisher ? *_impl_.event_.remove_publisher_ : reinterpret_cast<::subspace::ShadowRemovePublisher&>(::subspace::_ShadowRemovePublisher_default_instance_); +} +inline const ::subspace::ShadowRemovePublisher& ShadowEvent::remove_publisher() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.remove_publisher) + return _internal_remove_publisher(); +} +inline ::subspace::ShadowRemovePublisher* ShadowEvent::unsafe_arena_release_remove_publisher() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.remove_publisher) + if (event_case() == kRemovePublisher) { + clear_has_event(); + auto* temp = _impl_.event_.remove_publisher_; + _impl_.event_.remove_publisher_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_remove_publisher(::subspace::ShadowRemovePublisher* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_remove_publisher(); + _impl_.event_.remove_publisher_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.remove_publisher) +} +inline ::subspace::ShadowRemovePublisher* ShadowEvent::_internal_mutable_remove_publisher() { + if (event_case() != kRemovePublisher) { + clear_event(); + set_has_remove_publisher(); + _impl_.event_.remove_publisher_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowRemovePublisher>(GetArena()); + } + return _impl_.event_.remove_publisher_; +} +inline ::subspace::ShadowRemovePublisher* ShadowEvent::mutable_remove_publisher() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowRemovePublisher* _msg = _internal_mutable_remove_publisher(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.remove_publisher) + return _msg; +} + +// .subspace.ShadowAddSubscriber add_subscriber = 6; +inline bool ShadowEvent::has_add_subscriber() const { + return event_case() == kAddSubscriber; +} +inline bool ShadowEvent::_internal_has_add_subscriber() const { + return event_case() == kAddSubscriber; +} +inline void ShadowEvent::set_has_add_subscriber() { + _impl_._oneof_case_[0] = kAddSubscriber; +} +inline void ShadowEvent::clear_add_subscriber() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kAddSubscriber) { + if (GetArena() == nullptr) { + delete _impl_.event_.add_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.add_subscriber_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowAddSubscriber* ShadowEvent::release_add_subscriber() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.add_subscriber) + if (event_case() == kAddSubscriber) { + clear_has_event(); + auto* temp = _impl_.event_.add_subscriber_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.add_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowAddSubscriber& ShadowEvent::_internal_add_subscriber() const { + return event_case() == kAddSubscriber ? *_impl_.event_.add_subscriber_ : reinterpret_cast<::subspace::ShadowAddSubscriber&>(::subspace::_ShadowAddSubscriber_default_instance_); +} +inline const ::subspace::ShadowAddSubscriber& ShadowEvent::add_subscriber() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.add_subscriber) + return _internal_add_subscriber(); +} +inline ::subspace::ShadowAddSubscriber* ShadowEvent::unsafe_arena_release_add_subscriber() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.add_subscriber) + if (event_case() == kAddSubscriber) { + clear_has_event(); + auto* temp = _impl_.event_.add_subscriber_; + _impl_.event_.add_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_add_subscriber(::subspace::ShadowAddSubscriber* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_add_subscriber(); + _impl_.event_.add_subscriber_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.add_subscriber) +} +inline ::subspace::ShadowAddSubscriber* ShadowEvent::_internal_mutable_add_subscriber() { + if (event_case() != kAddSubscriber) { + clear_event(); + set_has_add_subscriber(); + _impl_.event_.add_subscriber_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowAddSubscriber>(GetArena()); + } + return _impl_.event_.add_subscriber_; +} +inline ::subspace::ShadowAddSubscriber* ShadowEvent::mutable_add_subscriber() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowAddSubscriber* _msg = _internal_mutable_add_subscriber(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.add_subscriber) + return _msg; +} + +// .subspace.ShadowRemoveSubscriber remove_subscriber = 7; +inline bool ShadowEvent::has_remove_subscriber() const { + return event_case() == kRemoveSubscriber; +} +inline bool ShadowEvent::_internal_has_remove_subscriber() const { + return event_case() == kRemoveSubscriber; +} +inline void ShadowEvent::set_has_remove_subscriber() { + _impl_._oneof_case_[0] = kRemoveSubscriber; +} +inline void ShadowEvent::clear_remove_subscriber() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kRemoveSubscriber) { + if (GetArena() == nullptr) { + delete _impl_.event_.remove_subscriber_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.remove_subscriber_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowRemoveSubscriber* ShadowEvent::release_remove_subscriber() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.remove_subscriber) + if (event_case() == kRemoveSubscriber) { + clear_has_event(); + auto* temp = _impl_.event_.remove_subscriber_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.remove_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowRemoveSubscriber& ShadowEvent::_internal_remove_subscriber() const { + return event_case() == kRemoveSubscriber ? *_impl_.event_.remove_subscriber_ : reinterpret_cast<::subspace::ShadowRemoveSubscriber&>(::subspace::_ShadowRemoveSubscriber_default_instance_); +} +inline const ::subspace::ShadowRemoveSubscriber& ShadowEvent::remove_subscriber() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.remove_subscriber) + return _internal_remove_subscriber(); +} +inline ::subspace::ShadowRemoveSubscriber* ShadowEvent::unsafe_arena_release_remove_subscriber() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.remove_subscriber) + if (event_case() == kRemoveSubscriber) { + clear_has_event(); + auto* temp = _impl_.event_.remove_subscriber_; + _impl_.event_.remove_subscriber_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_remove_subscriber(::subspace::ShadowRemoveSubscriber* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_remove_subscriber(); + _impl_.event_.remove_subscriber_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.remove_subscriber) +} +inline ::subspace::ShadowRemoveSubscriber* ShadowEvent::_internal_mutable_remove_subscriber() { + if (event_case() != kRemoveSubscriber) { + clear_event(); + set_has_remove_subscriber(); + _impl_.event_.remove_subscriber_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowRemoveSubscriber>(GetArena()); + } + return _impl_.event_.remove_subscriber_; +} +inline ::subspace::ShadowRemoveSubscriber* ShadowEvent::mutable_remove_subscriber() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowRemoveSubscriber* _msg = _internal_mutable_remove_subscriber(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.remove_subscriber) + return _msg; +} + +// .subspace.ShadowStateDump state_dump = 8; +inline bool ShadowEvent::has_state_dump() const { + return event_case() == kStateDump; +} +inline bool ShadowEvent::_internal_has_state_dump() const { + return event_case() == kStateDump; +} +inline void ShadowEvent::set_has_state_dump() { + _impl_._oneof_case_[0] = kStateDump; +} +inline void ShadowEvent::clear_state_dump() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kStateDump) { + if (GetArena() == nullptr) { + delete _impl_.event_.state_dump_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.state_dump_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowStateDump* ShadowEvent::release_state_dump() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.state_dump) + if (event_case() == kStateDump) { + clear_has_event(); + auto* temp = _impl_.event_.state_dump_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.state_dump_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowStateDump& ShadowEvent::_internal_state_dump() const { + return event_case() == kStateDump ? *_impl_.event_.state_dump_ : reinterpret_cast<::subspace::ShadowStateDump&>(::subspace::_ShadowStateDump_default_instance_); +} +inline const ::subspace::ShadowStateDump& ShadowEvent::state_dump() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.state_dump) + return _internal_state_dump(); +} +inline ::subspace::ShadowStateDump* ShadowEvent::unsafe_arena_release_state_dump() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.state_dump) + if (event_case() == kStateDump) { + clear_has_event(); + auto* temp = _impl_.event_.state_dump_; + _impl_.event_.state_dump_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_state_dump(::subspace::ShadowStateDump* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_state_dump(); + _impl_.event_.state_dump_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.state_dump) +} +inline ::subspace::ShadowStateDump* ShadowEvent::_internal_mutable_state_dump() { + if (event_case() != kStateDump) { + clear_event(); + set_has_state_dump(); + _impl_.event_.state_dump_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowStateDump>(GetArena()); + } + return _impl_.event_.state_dump_; +} +inline ::subspace::ShadowStateDump* ShadowEvent::mutable_state_dump() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowStateDump* _msg = _internal_mutable_state_dump(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.state_dump) + return _msg; +} + +// .subspace.ShadowStateDone state_done = 9; +inline bool ShadowEvent::has_state_done() const { + return event_case() == kStateDone; +} +inline bool ShadowEvent::_internal_has_state_done() const { + return event_case() == kStateDone; +} +inline void ShadowEvent::set_has_state_done() { + _impl_._oneof_case_[0] = kStateDone; +} +inline void ShadowEvent::clear_state_done() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kStateDone) { + if (GetArena() == nullptr) { + delete _impl_.event_.state_done_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.state_done_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowStateDone* ShadowEvent::release_state_done() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.state_done) + if (event_case() == kStateDone) { + clear_has_event(); + auto* temp = _impl_.event_.state_done_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.state_done_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowStateDone& ShadowEvent::_internal_state_done() const { + return event_case() == kStateDone ? *_impl_.event_.state_done_ : reinterpret_cast<::subspace::ShadowStateDone&>(::subspace::_ShadowStateDone_default_instance_); +} +inline const ::subspace::ShadowStateDone& ShadowEvent::state_done() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.state_done) + return _internal_state_done(); +} +inline ::subspace::ShadowStateDone* ShadowEvent::unsafe_arena_release_state_done() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.state_done) + if (event_case() == kStateDone) { + clear_has_event(); + auto* temp = _impl_.event_.state_done_; + _impl_.event_.state_done_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_state_done(::subspace::ShadowStateDone* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_state_done(); + _impl_.event_.state_done_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.state_done) +} +inline ::subspace::ShadowStateDone* ShadowEvent::_internal_mutable_state_done() { + if (event_case() != kStateDone) { + clear_event(); + set_has_state_done(); + _impl_.event_.state_done_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowStateDone>(GetArena()); + } + return _impl_.event_.state_done_; +} +inline ::subspace::ShadowStateDone* ShadowEvent::mutable_state_done() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowStateDone* _msg = _internal_mutable_state_done(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.state_done) + return _msg; +} + +// .subspace.ShadowRegisterClientBuffer register_client_buffer = 10; +inline bool ShadowEvent::has_register_client_buffer() const { + return event_case() == kRegisterClientBuffer; +} +inline bool ShadowEvent::_internal_has_register_client_buffer() const { + return event_case() == kRegisterClientBuffer; +} +inline void ShadowEvent::set_has_register_client_buffer() { + _impl_._oneof_case_[0] = kRegisterClientBuffer; +} +inline void ShadowEvent::clear_register_client_buffer() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kRegisterClientBuffer) { + if (GetArena() == nullptr) { + delete _impl_.event_.register_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.register_client_buffer_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowRegisterClientBuffer* ShadowEvent::release_register_client_buffer() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.register_client_buffer) + if (event_case() == kRegisterClientBuffer) { + clear_has_event(); + auto* temp = _impl_.event_.register_client_buffer_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.register_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowRegisterClientBuffer& ShadowEvent::_internal_register_client_buffer() const { + return event_case() == kRegisterClientBuffer ? *_impl_.event_.register_client_buffer_ : reinterpret_cast<::subspace::ShadowRegisterClientBuffer&>(::subspace::_ShadowRegisterClientBuffer_default_instance_); +} +inline const ::subspace::ShadowRegisterClientBuffer& ShadowEvent::register_client_buffer() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.register_client_buffer) + return _internal_register_client_buffer(); +} +inline ::subspace::ShadowRegisterClientBuffer* ShadowEvent::unsafe_arena_release_register_client_buffer() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.register_client_buffer) + if (event_case() == kRegisterClientBuffer) { + clear_has_event(); + auto* temp = _impl_.event_.register_client_buffer_; + _impl_.event_.register_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_register_client_buffer(::subspace::ShadowRegisterClientBuffer* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_register_client_buffer(); + _impl_.event_.register_client_buffer_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.register_client_buffer) +} +inline ::subspace::ShadowRegisterClientBuffer* ShadowEvent::_internal_mutable_register_client_buffer() { + if (event_case() != kRegisterClientBuffer) { + clear_event(); + set_has_register_client_buffer(); + _impl_.event_.register_client_buffer_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowRegisterClientBuffer>(GetArena()); + } + return _impl_.event_.register_client_buffer_; +} +inline ::subspace::ShadowRegisterClientBuffer* ShadowEvent::mutable_register_client_buffer() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowRegisterClientBuffer* _msg = _internal_mutable_register_client_buffer(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.register_client_buffer) + return _msg; +} + +// .subspace.ShadowUnregisterClientBuffer unregister_client_buffer = 11; +inline bool ShadowEvent::has_unregister_client_buffer() const { + return event_case() == kUnregisterClientBuffer; +} +inline bool ShadowEvent::_internal_has_unregister_client_buffer() const { + return event_case() == kUnregisterClientBuffer; +} +inline void ShadowEvent::set_has_unregister_client_buffer() { + _impl_._oneof_case_[0] = kUnregisterClientBuffer; +} +inline void ShadowEvent::clear_unregister_client_buffer() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kUnregisterClientBuffer) { + if (GetArena() == nullptr) { + delete _impl_.event_.unregister_client_buffer_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.unregister_client_buffer_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowUnregisterClientBuffer* ShadowEvent::release_unregister_client_buffer() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.unregister_client_buffer) + if (event_case() == kUnregisterClientBuffer) { + clear_has_event(); + auto* temp = _impl_.event_.unregister_client_buffer_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.unregister_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowUnregisterClientBuffer& ShadowEvent::_internal_unregister_client_buffer() const { + return event_case() == kUnregisterClientBuffer ? *_impl_.event_.unregister_client_buffer_ : reinterpret_cast<::subspace::ShadowUnregisterClientBuffer&>(::subspace::_ShadowUnregisterClientBuffer_default_instance_); +} +inline const ::subspace::ShadowUnregisterClientBuffer& ShadowEvent::unregister_client_buffer() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.unregister_client_buffer) + return _internal_unregister_client_buffer(); +} +inline ::subspace::ShadowUnregisterClientBuffer* ShadowEvent::unsafe_arena_release_unregister_client_buffer() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.unregister_client_buffer) + if (event_case() == kUnregisterClientBuffer) { + clear_has_event(); + auto* temp = _impl_.event_.unregister_client_buffer_; + _impl_.event_.unregister_client_buffer_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_unregister_client_buffer(::subspace::ShadowUnregisterClientBuffer* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_unregister_client_buffer(); + _impl_.event_.unregister_client_buffer_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.unregister_client_buffer) +} +inline ::subspace::ShadowUnregisterClientBuffer* ShadowEvent::_internal_mutable_unregister_client_buffer() { + if (event_case() != kUnregisterClientBuffer) { + clear_event(); + set_has_unregister_client_buffer(); + _impl_.event_.unregister_client_buffer_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowUnregisterClientBuffer>(GetArena()); + } + return _impl_.event_.unregister_client_buffer_; +} +inline ::subspace::ShadowUnregisterClientBuffer* ShadowEvent::mutable_unregister_client_buffer() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowUnregisterClientBuffer* _msg = _internal_mutable_unregister_client_buffer(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.unregister_client_buffer) + return _msg; +} + +// .subspace.ShadowUpdateChannelOptions update_channel_options = 12; +inline bool ShadowEvent::has_update_channel_options() const { + return event_case() == kUpdateChannelOptions; +} +inline bool ShadowEvent::_internal_has_update_channel_options() const { + return event_case() == kUpdateChannelOptions; +} +inline void ShadowEvent::set_has_update_channel_options() { + _impl_._oneof_case_[0] = kUpdateChannelOptions; +} +inline void ShadowEvent::clear_update_channel_options() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (event_case() == kUpdateChannelOptions) { + if (GetArena() == nullptr) { + delete _impl_.event_.update_channel_options_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.event_.update_channel_options_); + } + clear_has_event(); + } +} +inline ::subspace::ShadowUpdateChannelOptions* ShadowEvent::release_update_channel_options() { + // @@protoc_insertion_point(field_release:subspace.ShadowEvent.update_channel_options) + if (event_case() == kUpdateChannelOptions) { + clear_has_event(); + auto* temp = _impl_.event_.update_channel_options_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.event_.update_channel_options_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::subspace::ShadowUpdateChannelOptions& ShadowEvent::_internal_update_channel_options() const { + return event_case() == kUpdateChannelOptions ? *_impl_.event_.update_channel_options_ : reinterpret_cast<::subspace::ShadowUpdateChannelOptions&>(::subspace::_ShadowUpdateChannelOptions_default_instance_); +} +inline const ::subspace::ShadowUpdateChannelOptions& ShadowEvent::update_channel_options() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowEvent.update_channel_options) + return _internal_update_channel_options(); +} +inline ::subspace::ShadowUpdateChannelOptions* ShadowEvent::unsafe_arena_release_update_channel_options() { + // @@protoc_insertion_point(field_unsafe_arena_release:subspace.ShadowEvent.update_channel_options) + if (event_case() == kUpdateChannelOptions) { + clear_has_event(); + auto* temp = _impl_.event_.update_channel_options_; + _impl_.event_.update_channel_options_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ShadowEvent::unsafe_arena_set_allocated_update_channel_options(::subspace::ShadowUpdateChannelOptions* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_event(); + if (value) { + set_has_update_channel_options(); + _impl_.event_.update_channel_options_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowEvent.update_channel_options) +} +inline ::subspace::ShadowUpdateChannelOptions* ShadowEvent::_internal_mutable_update_channel_options() { + if (event_case() != kUpdateChannelOptions) { + clear_event(); + set_has_update_channel_options(); + _impl_.event_.update_channel_options_ = + ::google::protobuf::Message::DefaultConstruct<::subspace::ShadowUpdateChannelOptions>(GetArena()); + } + return _impl_.event_.update_channel_options_; +} +inline ::subspace::ShadowUpdateChannelOptions* ShadowEvent::mutable_update_channel_options() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::subspace::ShadowUpdateChannelOptions* _msg = _internal_mutable_update_channel_options(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowEvent.update_channel_options) + return _msg; +} + +inline bool ShadowEvent::has_event() const { + return event_case() != EVENT_NOT_SET; +} +inline void ShadowEvent::clear_has_event() { + _impl_._oneof_case_[0] = EVENT_NOT_SET; +} +inline ShadowEvent::EventCase ShadowEvent::event_case() const { + return ShadowEvent::EventCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ShadowInit + +// uint64 session_id = 1; +inline void ShadowInit::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = ::uint64_t{0u}; +} +inline ::uint64_t ShadowInit::session_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowInit.session_id) + return _internal_session_id(); +} +inline void ShadowInit::set_session_id(::uint64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowInit.session_id) +} +inline ::uint64_t ShadowInit::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void ShadowInit::_internal_set_session_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowCreateChannel + +// string channel_name = 1; +inline void ShadowCreateChannel::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowCreateChannel::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowCreateChannel::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.channel_name) +} +inline std::string* ShadowCreateChannel::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowCreateChannel.channel_name) + return _s; +} +inline const std::string& ShadowCreateChannel::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowCreateChannel::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowCreateChannel::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowCreateChannel::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowCreateChannel.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowCreateChannel::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowCreateChannel.channel_name) +} + +// int32 channel_id = 2; +inline void ShadowCreateChannel::clear_channel_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = 0; +} +inline ::int32_t ShadowCreateChannel::channel_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.channel_id) + return _internal_channel_id(); +} +inline void ShadowCreateChannel::set_channel_id(::int32_t value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.channel_id) +} +inline ::int32_t ShadowCreateChannel::_internal_channel_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_id_; +} +inline void ShadowCreateChannel::_internal_set_channel_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = value; +} + +// int32 slot_size = 3; +inline void ShadowCreateChannel::clear_slot_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = 0; +} +inline ::int32_t ShadowCreateChannel::slot_size() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.slot_size) + return _internal_slot_size(); +} +inline void ShadowCreateChannel::set_slot_size(::int32_t value) { + _internal_set_slot_size(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.slot_size) +} +inline ::int32_t ShadowCreateChannel::_internal_slot_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_size_; +} +inline void ShadowCreateChannel::_internal_set_slot_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_size_ = value; +} + +// int32 num_slots = 4; +inline void ShadowCreateChannel::clear_num_slots() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = 0; +} +inline ::int32_t ShadowCreateChannel::num_slots() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.num_slots) + return _internal_num_slots(); +} +inline void ShadowCreateChannel::set_num_slots(::int32_t value) { + _internal_set_num_slots(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.num_slots) +} +inline ::int32_t ShadowCreateChannel::_internal_num_slots() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_slots_; +} +inline void ShadowCreateChannel::_internal_set_num_slots(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_slots_ = value; +} + +// bytes type = 5; +inline void ShadowCreateChannel::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.ClearToEmpty(); +} +inline const std::string& ShadowCreateChannel::type() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.type) + return _internal_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowCreateChannel::set_type(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetBytes(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.type) +} +inline std::string* ShadowCreateChannel::mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowCreateChannel.type) + return _s; +} +inline const std::string& ShadowCreateChannel::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_.Get(); +} +inline void ShadowCreateChannel::_internal_set_type(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.Set(value, GetArena()); +} +inline std::string* ShadowCreateChannel::_internal_mutable_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.type_.Mutable( GetArena()); +} +inline std::string* ShadowCreateChannel::release_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowCreateChannel.type) + return _impl_.type_.Release(); +} +inline void ShadowCreateChannel::set_allocated_type(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) { + _impl_.type_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowCreateChannel.type) +} + +// bool is_local = 6; +inline void ShadowCreateChannel::clear_is_local() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_local_ = false; +} +inline bool ShadowCreateChannel::is_local() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.is_local) + return _internal_is_local(); +} +inline void ShadowCreateChannel::set_is_local(bool value) { + _internal_set_is_local(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.is_local) +} +inline bool ShadowCreateChannel::_internal_is_local() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_local_; +} +inline void ShadowCreateChannel::_internal_set_is_local(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_local_ = value; +} + +// bool is_reliable = 7; +inline void ShadowCreateChannel::clear_is_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = false; +} +inline bool ShadowCreateChannel::is_reliable() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.is_reliable) + return _internal_is_reliable(); +} +inline void ShadowCreateChannel::set_is_reliable(bool value) { + _internal_set_is_reliable(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.is_reliable) +} +inline bool ShadowCreateChannel::_internal_is_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_reliable_; +} +inline void ShadowCreateChannel::_internal_set_is_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = value; +} + +// bool is_fixed_size = 8; +inline void ShadowCreateChannel::clear_is_fixed_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_fixed_size_ = false; +} +inline bool ShadowCreateChannel::is_fixed_size() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.is_fixed_size) + return _internal_is_fixed_size(); +} +inline void ShadowCreateChannel::set_is_fixed_size(bool value) { + _internal_set_is_fixed_size(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.is_fixed_size) +} +inline bool ShadowCreateChannel::_internal_is_fixed_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_fixed_size_; +} +inline void ShadowCreateChannel::_internal_set_is_fixed_size(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_fixed_size_ = value; +} + +// int32 checksum_size = 9; +inline void ShadowCreateChannel::clear_checksum_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = 0; +} +inline ::int32_t ShadowCreateChannel::checksum_size() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.checksum_size) + return _internal_checksum_size(); +} +inline void ShadowCreateChannel::set_checksum_size(::int32_t value) { + _internal_set_checksum_size(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.checksum_size) +} +inline ::int32_t ShadowCreateChannel::_internal_checksum_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.checksum_size_; +} +inline void ShadowCreateChannel::_internal_set_checksum_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.checksum_size_ = value; +} + +// int32 metadata_size = 10; +inline void ShadowCreateChannel::clear_metadata_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = 0; +} +inline ::int32_t ShadowCreateChannel::metadata_size() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.metadata_size) + return _internal_metadata_size(); +} +inline void ShadowCreateChannel::set_metadata_size(::int32_t value) { + _internal_set_metadata_size(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.metadata_size) +} +inline ::int32_t ShadowCreateChannel::_internal_metadata_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.metadata_size_; +} +inline void ShadowCreateChannel::_internal_set_metadata_size(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.metadata_size_ = value; +} + +// string mux = 11; +inline void ShadowCreateChannel::clear_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.ClearToEmpty(); +} +inline const std::string& ShadowCreateChannel::mux() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.mux) + return _internal_mux(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowCreateChannel::set_mux(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.mux) +} +inline std::string* ShadowCreateChannel::mutable_mux() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_mux(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowCreateChannel.mux) + return _s; +} +inline const std::string& ShadowCreateChannel::_internal_mux() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.mux_.Get(); +} +inline void ShadowCreateChannel::_internal_set_mux(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.Set(value, GetArena()); +} +inline std::string* ShadowCreateChannel::_internal_mutable_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.mux_.Mutable( GetArena()); +} +inline std::string* ShadowCreateChannel::release_mux() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowCreateChannel.mux) + return _impl_.mux_.Release(); +} +inline void ShadowCreateChannel::set_allocated_mux(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mux_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.mux_.IsDefault()) { + _impl_.mux_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowCreateChannel.mux) +} + +// int32 vchan_id = 12; +inline void ShadowCreateChannel::clear_vchan_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = 0; +} +inline ::int32_t ShadowCreateChannel::vchan_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.vchan_id) + return _internal_vchan_id(); +} +inline void ShadowCreateChannel::set_vchan_id(::int32_t value) { + _internal_set_vchan_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.vchan_id) +} +inline ::int32_t ShadowCreateChannel::_internal_vchan_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vchan_id_; +} +inline void ShadowCreateChannel::_internal_set_vchan_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vchan_id_ = value; +} + +// bool has_split_buffer_options = 13; +inline void ShadowCreateChannel::clear_has_split_buffer_options() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_split_buffer_options_ = false; +} +inline bool ShadowCreateChannel::has_split_buffer_options() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.has_split_buffer_options) + return _internal_has_split_buffer_options(); +} +inline void ShadowCreateChannel::set_has_split_buffer_options(bool value) { + _internal_set_has_split_buffer_options(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.has_split_buffer_options) +} +inline bool ShadowCreateChannel::_internal_has_split_buffer_options() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.has_split_buffer_options_; +} +inline void ShadowCreateChannel::_internal_set_has_split_buffer_options(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_split_buffer_options_ = value; +} + +// bool use_split_buffers = 14; +inline void ShadowCreateChannel::clear_use_split_buffers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = false; +} +inline bool ShadowCreateChannel::use_split_buffers() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.use_split_buffers) + return _internal_use_split_buffers(); +} +inline void ShadowCreateChannel::set_use_split_buffers(bool value) { + _internal_set_use_split_buffers(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.use_split_buffers) +} +inline bool ShadowCreateChannel::_internal_use_split_buffers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.use_split_buffers_; +} +inline void ShadowCreateChannel::_internal_set_use_split_buffers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = value; +} + +// bool has_max_publishers = 15; +inline void ShadowCreateChannel::clear_has_max_publishers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_max_publishers_ = false; +} +inline bool ShadowCreateChannel::has_max_publishers() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.has_max_publishers) + return _internal_has_max_publishers(); +} +inline void ShadowCreateChannel::set_has_max_publishers(bool value) { + _internal_set_has_max_publishers(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.has_max_publishers) +} +inline bool ShadowCreateChannel::_internal_has_max_publishers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.has_max_publishers_; +} +inline void ShadowCreateChannel::_internal_set_has_max_publishers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_max_publishers_ = value; +} + +// int32 max_publishers = 16; +inline void ShadowCreateChannel::clear_max_publishers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_publishers_ = 0; +} +inline ::int32_t ShadowCreateChannel::max_publishers() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.max_publishers) + return _internal_max_publishers(); +} +inline void ShadowCreateChannel::set_max_publishers(::int32_t value) { + _internal_set_max_publishers(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.max_publishers) +} +inline ::int32_t ShadowCreateChannel::_internal_max_publishers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_publishers_; +} +inline void ShadowCreateChannel::_internal_set_max_publishers(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_publishers_ = value; +} + +// bool split_buffers_over_bridge = 17; +inline void ShadowCreateChannel::clear_split_buffers_over_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = false; +} +inline bool ShadowCreateChannel::split_buffers_over_bridge() const { + // @@protoc_insertion_point(field_get:subspace.ShadowCreateChannel.split_buffers_over_bridge) + return _internal_split_buffers_over_bridge(); +} +inline void ShadowCreateChannel::set_split_buffers_over_bridge(bool value) { + _internal_set_split_buffers_over_bridge(value); + // @@protoc_insertion_point(field_set:subspace.ShadowCreateChannel.split_buffers_over_bridge) +} +inline bool ShadowCreateChannel::_internal_split_buffers_over_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.split_buffers_over_bridge_; +} +inline void ShadowCreateChannel::_internal_set_split_buffers_over_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowRemoveChannel + +// string channel_name = 1; +inline void ShadowRemoveChannel::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowRemoveChannel::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowRemoveChannel.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowRemoveChannel::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowRemoveChannel.channel_name) +} +inline std::string* ShadowRemoveChannel::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowRemoveChannel.channel_name) + return _s; +} +inline const std::string& ShadowRemoveChannel::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowRemoveChannel::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowRemoveChannel::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowRemoveChannel::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowRemoveChannel.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowRemoveChannel::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowRemoveChannel.channel_name) +} + +// int32 channel_id = 2; +inline void ShadowRemoveChannel::clear_channel_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = 0; +} +inline ::int32_t ShadowRemoveChannel::channel_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowRemoveChannel.channel_id) + return _internal_channel_id(); +} +inline void ShadowRemoveChannel::set_channel_id(::int32_t value) { + _internal_set_channel_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowRemoveChannel.channel_id) +} +inline ::int32_t ShadowRemoveChannel::_internal_channel_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_id_; +} +inline void ShadowRemoveChannel::_internal_set_channel_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_id_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowAddPublisher + +// string channel_name = 1; +inline void ShadowAddPublisher::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowAddPublisher::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowAddPublisher::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.channel_name) +} +inline std::string* ShadowAddPublisher::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowAddPublisher.channel_name) + return _s; +} +inline const std::string& ShadowAddPublisher::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowAddPublisher::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowAddPublisher::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowAddPublisher::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowAddPublisher.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowAddPublisher::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowAddPublisher.channel_name) +} + +// int32 publisher_id = 2; +inline void ShadowAddPublisher::clear_publisher_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = 0; +} +inline ::int32_t ShadowAddPublisher::publisher_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.publisher_id) + return _internal_publisher_id(); +} +inline void ShadowAddPublisher::set_publisher_id(::int32_t value) { + _internal_set_publisher_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.publisher_id) +} +inline ::int32_t ShadowAddPublisher::_internal_publisher_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.publisher_id_; +} +inline void ShadowAddPublisher::_internal_set_publisher_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = value; +} + +// bool is_reliable = 3; +inline void ShadowAddPublisher::clear_is_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = false; +} +inline bool ShadowAddPublisher::is_reliable() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.is_reliable) + return _internal_is_reliable(); +} +inline void ShadowAddPublisher::set_is_reliable(bool value) { + _internal_set_is_reliable(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.is_reliable) +} +inline bool ShadowAddPublisher::_internal_is_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_reliable_; +} +inline void ShadowAddPublisher::_internal_set_is_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = value; +} + +// bool is_local = 4; +inline void ShadowAddPublisher::clear_is_local() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_local_ = false; +} +inline bool ShadowAddPublisher::is_local() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.is_local) + return _internal_is_local(); +} +inline void ShadowAddPublisher::set_is_local(bool value) { + _internal_set_is_local(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.is_local) +} +inline bool ShadowAddPublisher::_internal_is_local() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_local_; +} +inline void ShadowAddPublisher::_internal_set_is_local(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_local_ = value; +} + +// bool is_bridge = 5; +inline void ShadowAddPublisher::clear_is_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = false; +} +inline bool ShadowAddPublisher::is_bridge() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.is_bridge) + return _internal_is_bridge(); +} +inline void ShadowAddPublisher::set_is_bridge(bool value) { + _internal_set_is_bridge(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.is_bridge) +} +inline bool ShadowAddPublisher::_internal_is_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_bridge_; +} +inline void ShadowAddPublisher::_internal_set_is_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = value; +} + +// bool is_fixed_size = 6; +inline void ShadowAddPublisher::clear_is_fixed_size() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_fixed_size_ = false; +} +inline bool ShadowAddPublisher::is_fixed_size() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.is_fixed_size) + return _internal_is_fixed_size(); +} +inline void ShadowAddPublisher::set_is_fixed_size(bool value) { + _internal_set_is_fixed_size(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.is_fixed_size) +} +inline bool ShadowAddPublisher::_internal_is_fixed_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_fixed_size_; +} +inline void ShadowAddPublisher::_internal_set_is_fixed_size(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_fixed_size_ = value; +} + +// bool notify_retirement = 7; +inline void ShadowAddPublisher::clear_notify_retirement() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = false; +} +inline bool ShadowAddPublisher::notify_retirement() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.notify_retirement) + return _internal_notify_retirement(); +} +inline void ShadowAddPublisher::set_notify_retirement(bool value) { + _internal_set_notify_retirement(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.notify_retirement) +} +inline bool ShadowAddPublisher::_internal_notify_retirement() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.notify_retirement_; +} +inline void ShadowAddPublisher::_internal_set_notify_retirement(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.notify_retirement_ = value; +} + +// bool for_tunnel = 8; +inline void ShadowAddPublisher::clear_for_tunnel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = false; +} +inline bool ShadowAddPublisher::for_tunnel() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddPublisher.for_tunnel) + return _internal_for_tunnel(); +} +inline void ShadowAddPublisher::set_for_tunnel(bool value) { + _internal_set_for_tunnel(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddPublisher.for_tunnel) +} +inline bool ShadowAddPublisher::_internal_for_tunnel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.for_tunnel_; +} +inline void ShadowAddPublisher::_internal_set_for_tunnel(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowRemovePublisher + +// string channel_name = 1; +inline void ShadowRemovePublisher::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowRemovePublisher::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowRemovePublisher.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowRemovePublisher::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowRemovePublisher.channel_name) +} +inline std::string* ShadowRemovePublisher::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowRemovePublisher.channel_name) + return _s; +} +inline const std::string& ShadowRemovePublisher::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowRemovePublisher::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowRemovePublisher::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowRemovePublisher::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowRemovePublisher.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowRemovePublisher::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowRemovePublisher.channel_name) +} + +// int32 publisher_id = 2; +inline void ShadowRemovePublisher::clear_publisher_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = 0; +} +inline ::int32_t ShadowRemovePublisher::publisher_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowRemovePublisher.publisher_id) + return _internal_publisher_id(); +} +inline void ShadowRemovePublisher::set_publisher_id(::int32_t value) { + _internal_set_publisher_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowRemovePublisher.publisher_id) +} +inline ::int32_t ShadowRemovePublisher::_internal_publisher_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.publisher_id_; +} +inline void ShadowRemovePublisher::_internal_set_publisher_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.publisher_id_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowAddSubscriber + +// string channel_name = 1; +inline void ShadowAddSubscriber::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowAddSubscriber::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowAddSubscriber.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowAddSubscriber::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowAddSubscriber.channel_name) +} +inline std::string* ShadowAddSubscriber::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowAddSubscriber.channel_name) + return _s; +} +inline const std::string& ShadowAddSubscriber::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowAddSubscriber::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowAddSubscriber::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowAddSubscriber::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowAddSubscriber.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowAddSubscriber::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowAddSubscriber.channel_name) +} + +// int32 subscriber_id = 2; +inline void ShadowAddSubscriber::clear_subscriber_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = 0; +} +inline ::int32_t ShadowAddSubscriber::subscriber_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddSubscriber.subscriber_id) + return _internal_subscriber_id(); +} +inline void ShadowAddSubscriber::set_subscriber_id(::int32_t value) { + _internal_set_subscriber_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddSubscriber.subscriber_id) +} +inline ::int32_t ShadowAddSubscriber::_internal_subscriber_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.subscriber_id_; +} +inline void ShadowAddSubscriber::_internal_set_subscriber_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = value; +} + +// bool is_reliable = 3; +inline void ShadowAddSubscriber::clear_is_reliable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = false; +} +inline bool ShadowAddSubscriber::is_reliable() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddSubscriber.is_reliable) + return _internal_is_reliable(); +} +inline void ShadowAddSubscriber::set_is_reliable(bool value) { + _internal_set_is_reliable(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddSubscriber.is_reliable) +} +inline bool ShadowAddSubscriber::_internal_is_reliable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_reliable_; +} +inline void ShadowAddSubscriber::_internal_set_is_reliable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_reliable_ = value; +} + +// bool is_bridge = 4; +inline void ShadowAddSubscriber::clear_is_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = false; +} +inline bool ShadowAddSubscriber::is_bridge() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddSubscriber.is_bridge) + return _internal_is_bridge(); +} +inline void ShadowAddSubscriber::set_is_bridge(bool value) { + _internal_set_is_bridge(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddSubscriber.is_bridge) +} +inline bool ShadowAddSubscriber::_internal_is_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_bridge_; +} +inline void ShadowAddSubscriber::_internal_set_is_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_bridge_ = value; +} + +// int32 max_active_messages = 5; +inline void ShadowAddSubscriber::clear_max_active_messages() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_active_messages_ = 0; +} +inline ::int32_t ShadowAddSubscriber::max_active_messages() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddSubscriber.max_active_messages) + return _internal_max_active_messages(); +} +inline void ShadowAddSubscriber::set_max_active_messages(::int32_t value) { + _internal_set_max_active_messages(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddSubscriber.max_active_messages) +} +inline ::int32_t ShadowAddSubscriber::_internal_max_active_messages() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_active_messages_; +} +inline void ShadowAddSubscriber::_internal_set_max_active_messages(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_active_messages_ = value; +} + +// bool for_tunnel = 6; +inline void ShadowAddSubscriber::clear_for_tunnel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = false; +} +inline bool ShadowAddSubscriber::for_tunnel() const { + // @@protoc_insertion_point(field_get:subspace.ShadowAddSubscriber.for_tunnel) + return _internal_for_tunnel(); +} +inline void ShadowAddSubscriber::set_for_tunnel(bool value) { + _internal_set_for_tunnel(value); + // @@protoc_insertion_point(field_set:subspace.ShadowAddSubscriber.for_tunnel) +} +inline bool ShadowAddSubscriber::_internal_for_tunnel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.for_tunnel_; +} +inline void ShadowAddSubscriber::_internal_set_for_tunnel(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.for_tunnel_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowRemoveSubscriber + +// string channel_name = 1; +inline void ShadowRemoveSubscriber::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowRemoveSubscriber::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowRemoveSubscriber.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowRemoveSubscriber::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowRemoveSubscriber.channel_name) +} +inline std::string* ShadowRemoveSubscriber::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowRemoveSubscriber.channel_name) + return _s; +} +inline const std::string& ShadowRemoveSubscriber::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowRemoveSubscriber::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowRemoveSubscriber::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowRemoveSubscriber::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowRemoveSubscriber.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowRemoveSubscriber::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowRemoveSubscriber.channel_name) +} + +// int32 subscriber_id = 2; +inline void ShadowRemoveSubscriber::clear_subscriber_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = 0; +} +inline ::int32_t ShadowRemoveSubscriber::subscriber_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowRemoveSubscriber.subscriber_id) + return _internal_subscriber_id(); +} +inline void ShadowRemoveSubscriber::set_subscriber_id(::int32_t value) { + _internal_set_subscriber_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowRemoveSubscriber.subscriber_id) +} +inline ::int32_t ShadowRemoveSubscriber::_internal_subscriber_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.subscriber_id_; +} +inline void ShadowRemoveSubscriber::_internal_set_subscriber_id(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.subscriber_id_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowStateDump + +// uint64 session_id = 1; +inline void ShadowStateDump::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = ::uint64_t{0u}; +} +inline ::uint64_t ShadowStateDump::session_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowStateDump.session_id) + return _internal_session_id(); +} +inline void ShadowStateDump::set_session_id(::uint64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowStateDump.session_id) +} +inline ::uint64_t ShadowStateDump::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void ShadowStateDump::_internal_set_session_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// int32 num_channels = 2; +inline void ShadowStateDump::clear_num_channels() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_channels_ = 0; +} +inline ::int32_t ShadowStateDump::num_channels() const { + // @@protoc_insertion_point(field_get:subspace.ShadowStateDump.num_channels) + return _internal_num_channels(); +} +inline void ShadowStateDump::set_num_channels(::int32_t value) { + _internal_set_num_channels(value); + // @@protoc_insertion_point(field_set:subspace.ShadowStateDump.num_channels) +} +inline ::int32_t ShadowStateDump::_internal_num_channels() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.num_channels_; +} +inline void ShadowStateDump::_internal_set_num_channels(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.num_channels_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowStateDone + +// ------------------------------------------------------------------- + +// ShadowRegisterClientBuffer + +// .subspace.ClientBufferHandleMetadataProto metadata = 1; +inline bool ShadowRegisterClientBuffer::has_metadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.metadata_ != nullptr); + return value; +} +inline void ShadowRegisterClientBuffer::clear_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.metadata_ != nullptr) _impl_.metadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::subspace::ClientBufferHandleMetadataProto& ShadowRegisterClientBuffer::_internal_metadata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::subspace::ClientBufferHandleMetadataProto* p = _impl_.metadata_; + return p != nullptr ? *p : reinterpret_cast(::subspace::_ClientBufferHandleMetadataProto_default_instance_); +} +inline const ::subspace::ClientBufferHandleMetadataProto& ShadowRegisterClientBuffer::metadata() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowRegisterClientBuffer.metadata) + return _internal_metadata(); +} +inline void ShadowRegisterClientBuffer::unsafe_arena_set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.metadata_); + } + _impl_.metadata_ = reinterpret_cast<::subspace::ClientBufferHandleMetadataProto*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:subspace.ShadowRegisterClientBuffer.metadata) +} +inline ::subspace::ClientBufferHandleMetadataProto* ShadowRegisterClientBuffer::release_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ClientBufferHandleMetadataProto* released = _impl_.metadata_; + _impl_.metadata_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::subspace::ClientBufferHandleMetadataProto* ShadowRegisterClientBuffer::unsafe_arena_release_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowRegisterClientBuffer.metadata) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::subspace::ClientBufferHandleMetadataProto* temp = _impl_.metadata_; + _impl_.metadata_ = nullptr; + return temp; +} +inline ::subspace::ClientBufferHandleMetadataProto* ShadowRegisterClientBuffer::_internal_mutable_metadata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.metadata_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::subspace::ClientBufferHandleMetadataProto>(GetArena()); + _impl_.metadata_ = reinterpret_cast<::subspace::ClientBufferHandleMetadataProto*>(p); + } + return _impl_.metadata_; +} +inline ::subspace::ClientBufferHandleMetadataProto* ShadowRegisterClientBuffer::mutable_metadata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::subspace::ClientBufferHandleMetadataProto* _msg = _internal_mutable_metadata(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowRegisterClientBuffer.metadata) + return _msg; +} +inline void ShadowRegisterClientBuffer::set_allocated_metadata(::subspace::ClientBufferHandleMetadataProto* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.metadata_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.metadata_ = reinterpret_cast<::subspace::ClientBufferHandleMetadataProto*>(value); + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowRegisterClientBuffer.metadata) +} + +// ------------------------------------------------------------------- + +// ShadowUnregisterClientBuffer + +// string channel_name = 1; +inline void ShadowUnregisterClientBuffer::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowUnregisterClientBuffer::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowUnregisterClientBuffer.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowUnregisterClientBuffer::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowUnregisterClientBuffer.channel_name) +} +inline std::string* ShadowUnregisterClientBuffer::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowUnregisterClientBuffer.channel_name) + return _s; +} +inline const std::string& ShadowUnregisterClientBuffer::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowUnregisterClientBuffer::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowUnregisterClientBuffer::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowUnregisterClientBuffer::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowUnregisterClientBuffer.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowUnregisterClientBuffer::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowUnregisterClientBuffer.channel_name) +} + +// uint64 session_id = 2; +inline void ShadowUnregisterClientBuffer::clear_session_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = ::uint64_t{0u}; +} +inline ::uint64_t ShadowUnregisterClientBuffer::session_id() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUnregisterClientBuffer.session_id) + return _internal_session_id(); +} +inline void ShadowUnregisterClientBuffer::set_session_id(::uint64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUnregisterClientBuffer.session_id) +} +inline ::uint64_t ShadowUnregisterClientBuffer::_internal_session_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.session_id_; +} +inline void ShadowUnregisterClientBuffer::_internal_set_session_id(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.session_id_ = value; +} + +// uint32 buffer_index = 3; +inline void ShadowUnregisterClientBuffer::clear_buffer_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.buffer_index_ = 0u; +} +inline ::uint32_t ShadowUnregisterClientBuffer::buffer_index() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUnregisterClientBuffer.buffer_index) + return _internal_buffer_index(); +} +inline void ShadowUnregisterClientBuffer::set_buffer_index(::uint32_t value) { + _internal_set_buffer_index(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUnregisterClientBuffer.buffer_index) +} +inline ::uint32_t ShadowUnregisterClientBuffer::_internal_buffer_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.buffer_index_; +} +inline void ShadowUnregisterClientBuffer::_internal_set_buffer_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.buffer_index_ = value; +} + +// ------------------------------------------------------------------- + +// ShadowUpdateChannelOptions + +// string channel_name = 1; +inline void ShadowUpdateChannelOptions::clear_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.ClearToEmpty(); +} +inline const std::string& ShadowUpdateChannelOptions::channel_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:subspace.ShadowUpdateChannelOptions.channel_name) + return _internal_channel_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ShadowUpdateChannelOptions::set_channel_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:subspace.ShadowUpdateChannelOptions.channel_name) +} +inline std::string* ShadowUpdateChannelOptions::mutable_channel_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_channel_name(); + // @@protoc_insertion_point(field_mutable:subspace.ShadowUpdateChannelOptions.channel_name) + return _s; +} +inline const std::string& ShadowUpdateChannelOptions::_internal_channel_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.channel_name_.Get(); +} +inline void ShadowUpdateChannelOptions::_internal_set_channel_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.Set(value, GetArena()); +} +inline std::string* ShadowUpdateChannelOptions::_internal_mutable_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.channel_name_.Mutable( GetArena()); +} +inline std::string* ShadowUpdateChannelOptions::release_channel_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:subspace.ShadowUpdateChannelOptions.channel_name) + return _impl_.channel_name_.Release(); +} +inline void ShadowUpdateChannelOptions::set_allocated_channel_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.channel_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.channel_name_.IsDefault()) { + _impl_.channel_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:subspace.ShadowUpdateChannelOptions.channel_name) +} + +// bool has_split_buffer_options = 2; +inline void ShadowUpdateChannelOptions::clear_has_split_buffer_options() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_split_buffer_options_ = false; +} +inline bool ShadowUpdateChannelOptions::has_split_buffer_options() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUpdateChannelOptions.has_split_buffer_options) + return _internal_has_split_buffer_options(); +} +inline void ShadowUpdateChannelOptions::set_has_split_buffer_options(bool value) { + _internal_set_has_split_buffer_options(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUpdateChannelOptions.has_split_buffer_options) +} +inline bool ShadowUpdateChannelOptions::_internal_has_split_buffer_options() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.has_split_buffer_options_; +} +inline void ShadowUpdateChannelOptions::_internal_set_has_split_buffer_options(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_split_buffer_options_ = value; +} + +// bool use_split_buffers = 3; +inline void ShadowUpdateChannelOptions::clear_use_split_buffers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = false; +} +inline bool ShadowUpdateChannelOptions::use_split_buffers() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUpdateChannelOptions.use_split_buffers) + return _internal_use_split_buffers(); +} +inline void ShadowUpdateChannelOptions::set_use_split_buffers(bool value) { + _internal_set_use_split_buffers(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUpdateChannelOptions.use_split_buffers) +} +inline bool ShadowUpdateChannelOptions::_internal_use_split_buffers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.use_split_buffers_; +} +inline void ShadowUpdateChannelOptions::_internal_set_use_split_buffers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.use_split_buffers_ = value; +} + +// bool has_max_publishers = 4; +inline void ShadowUpdateChannelOptions::clear_has_max_publishers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_max_publishers_ = false; +} +inline bool ShadowUpdateChannelOptions::has_max_publishers() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUpdateChannelOptions.has_max_publishers) + return _internal_has_max_publishers(); +} +inline void ShadowUpdateChannelOptions::set_has_max_publishers(bool value) { + _internal_set_has_max_publishers(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUpdateChannelOptions.has_max_publishers) +} +inline bool ShadowUpdateChannelOptions::_internal_has_max_publishers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.has_max_publishers_; +} +inline void ShadowUpdateChannelOptions::_internal_set_has_max_publishers(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.has_max_publishers_ = value; +} + +// int32 max_publishers = 5; +inline void ShadowUpdateChannelOptions::clear_max_publishers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_publishers_ = 0; +} +inline ::int32_t ShadowUpdateChannelOptions::max_publishers() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUpdateChannelOptions.max_publishers) + return _internal_max_publishers(); +} +inline void ShadowUpdateChannelOptions::set_max_publishers(::int32_t value) { + _internal_set_max_publishers(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUpdateChannelOptions.max_publishers) +} +inline ::int32_t ShadowUpdateChannelOptions::_internal_max_publishers() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_publishers_; +} +inline void ShadowUpdateChannelOptions::_internal_set_max_publishers(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_publishers_ = value; +} + +// bool split_buffers_over_bridge = 6; +inline void ShadowUpdateChannelOptions::clear_split_buffers_over_bridge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = false; +} +inline bool ShadowUpdateChannelOptions::split_buffers_over_bridge() const { + // @@protoc_insertion_point(field_get:subspace.ShadowUpdateChannelOptions.split_buffers_over_bridge) + return _internal_split_buffers_over_bridge(); +} +inline void ShadowUpdateChannelOptions::set_split_buffers_over_bridge(bool value) { + _internal_set_split_buffers_over_bridge(value); + // @@protoc_insertion_point(field_set:subspace.ShadowUpdateChannelOptions.split_buffers_over_bridge) +} +inline bool ShadowUpdateChannelOptions::_internal_split_buffers_over_bridge() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.split_buffers_over_bridge_; +} +inline void ShadowUpdateChannelOptions::_internal_set_split_buffers_over_bridge(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.split_buffers_over_bridge_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace subspace + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // subspace_2eproto_2epb_2eh diff --git a/rust_client/CMakeLists.txt b/rust_client/CMakeLists.txt index 9c4865b..540231b 100644 --- a/rust_client/CMakeLists.txt +++ b/rust_client/CMakeLists.txt @@ -12,6 +12,11 @@ if(NOT CARGO_EXECUTABLE) return() endif() +if(CMAKE_CROSSCOMPILING) + message(STATUS "Cross-compiling -- skipping rust_client (no cross-Cargo support)") + return() +endif() + if(CMAKE_BUILD_TYPE STREQUAL "Release") set(CARGO_BUILD_FLAG "--release") set(CARGO_TARGET_DIR "release") diff --git a/server/Android.bp b/server/Android.bp new file mode 100644 index 0000000..e3a4c69 --- /dev/null +++ b/server/Android.bp @@ -0,0 +1,72 @@ +// Copyright 2023-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +cc_library_static { + name: "libsubspace_server", + defaults: ["subspace_defaults"], + srcs: [ + "server.cc", + "client_handler.cc", + "server_channel.cc", + "shadow_replicator.cc", + ], + export_include_dirs: ["."], + local_include_dirs: [".."], + static_libs: [ + "libsubspace_common", + "libsubspace_proto", + "libcoroutines", + "libcpp_toolbelt", + ], + shared_libs: [ + "libsubspace_client", + "libprotobuf-cpp-lite", + "liblog", + ], + header_libs: [ + "libabseil-headers", + ], + whole_static_libs: [ + "libabsl_status", + "libabsl_statusor", + "libabsl_strings", + "libabsl_str_format_internal", + "libabsl_flat_hash_map", + "libabsl_flat_hash_set", + "libabsl_flags", + "libabsl_flags_parse", + ], +} + +cc_binary { + name: "subspace_server", + defaults: ["subspace_defaults"], + srcs: ["main.cc"], + static_libs: [ + "libsubspace_server", + "libsubspace_common", + "libsubspace_proto", + "libcoroutines", + "libcpp_toolbelt", + ], + shared_libs: [ + "libsubspace_client", + "libprotobuf-cpp-lite", + "liblog", + "libdl", + ], + header_libs: [ + "libabseil-headers", + ], + whole_static_libs: [ + "libabsl_status", + "libabsl_statusor", + "libabsl_strings", + "libabsl_str_format_internal", + "libabsl_flat_hash_map", + "libabsl_flat_hash_set", + "libabsl_flags", + "libabsl_flags_parse", + ], +} diff --git a/server/BUILD.bazel b/server/BUILD.bazel index 2c4163c..e0914a7 100644 --- a/server/BUILD.bazel +++ b/server/BUILD.bazel @@ -54,7 +54,8 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], - "//conditions:default": [ "-lrt" , "-ldl"], + "//:android": ["-llog", "-ldl"], + "//conditions:default": ["-lrt", "-ldl"], }), ) diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index dd49d2c..3f35306 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -32,7 +32,9 @@ target_link_libraries(subspace_server PUBLIC absl::flags_parse ) -if(NOT APPLE) +if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT ANDROID) target_link_libraries(subspace_server PRIVATE rt dl) +elseif(ANDROID) + target_link_libraries(subspace_server PRIVATE dl log) endif() diff --git a/server/main.cc b/server/main.cc index 91ddb08..c899178 100644 --- a/server/main.cc +++ b/server/main.cc @@ -16,8 +16,13 @@ void Signal(int sig) { raise(sig); } +#if defined(__ANDROID__) +ABSL_FLAG(std::string, socket, "/data/local/tmp/subspace", + "Name of Unix socket to listen on"); +#else ABSL_FLAG(std::string, socket, "/tmp/subspace", "Name of Unix socket to listen on"); +#endif ABSL_FLAG(int, disc_port, 6502, "Discovery UDP port"); ABSL_FLAG(int, peer_port, 6502, "Discovery peer UDP port"); ABSL_FLAG(std::string, peer_address, "", "Bridge peer hostname or IP address"); @@ -27,11 +32,10 @@ ABSL_FLAG(bool, local, false, "Use local computer only"); ABSL_FLAG(int, notify_fd, -1, "File descriptor to notify of startup"); ABSL_FLAG(std::string, machine, "", "Machine name"); -// macOS and QNX both use /tmp-shadowed POSIX shared memory, so it's safe and -// useful to clean up the filesystem on startup there. On Linux the server -// uses /dev/shm directly and tests routinely run multiple instances, so we -// keep it off by default. -#if defined(__APPLE__) || defined(__QNX__) || defined(__QNXNTO__) +// macOS, Android, and QNX all benefit from cleaning up the filesystem on +// startup. On Linux the server uses /dev/shm directly and tests routinely +// run multiple instances, so we keep it off by default. +#if defined(__APPLE__) || defined(__ANDROID__) || defined(__QNX__) || defined(__QNXNTO__) ABSL_FLAG(bool, cleanup_filesystem, true, "Cleanup the filesystem on server startup"); #else ABSL_FLAG(bool, cleanup_filesystem, false, "Cleanup the filesystem on server startup"); diff --git a/server/server.cc b/server/server.cc index 3d00b93..fa2ae90 100644 --- a/server/server.cc +++ b/server/server.cc @@ -465,7 +465,18 @@ void Server::CleanupAfterSession() { std::string session_shm_file_prefix = "subspace_." + std::to_string(session_id_); -#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + const std::string &shm_dir = GetAndroidShmDir(); + if (std::filesystem::exists(shm_dir)) { + for (const auto &entry : std::filesystem::directory_iterator(shm_dir)) { + std::string filename = entry.path().filename().string(); + if (filename.rfind("subspace_", 0) == 0) { + (void)std::filesystem::remove(entry.path()); + } + } + } + +#elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX // Remove all files starting with "subspace_SESSION" in /tmp. These refer to // shared memory segments names "subspace_INODE". for (const auto &entry : std::filesystem::directory_iterator("/tmp")) { @@ -506,7 +517,18 @@ void Server::CleanupAfterSession() { void Server::CleanupFilesystem() { logger_.Log(toolbelt::LogLevel::kInfo, "Cleaning up filesystem..."); -#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + const std::string &shm_dir = GetAndroidShmDir(); + if (std::filesystem::exists(shm_dir)) { + for (const auto &entry : std::filesystem::directory_iterator(shm_dir)) { + std::string filename = entry.path().filename().string(); + if (filename.rfind("subspace_", 0) == 0) { + (void)std::filesystem::remove(entry.path()); + } + } + } + +#elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX // Remove all files starting with "subspace_" in /tmp. These refer to // shared memory segments names "subspace_INODE". for (const auto &entry : std::filesystem::directory_iterator("/tmp")) { @@ -545,6 +567,18 @@ void Server::CleanupFilesystem() { absl::Status Server::Run() { std::vector poll_fds; +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + // Ensure the Android SHM directory exists. + const std::string &shm_dir = GetAndroidShmDir(); + std::error_code ec; + std::filesystem::create_directories(shm_dir, ec); + if (ec) { + return absl::InternalError( + absl::StrFormat("Failed to create SHM directory %s: %s", shm_dir, + ec.message())); + } +#endif + #ifndef __linux__ // Remove socket name if it exists. On Non-Linux systems the socket // is a file in the file system. On Linux it's in the abstract diff --git a/server/server_channel.cc b/server/server_channel.cc index a9e5a98..a77ca06 100644 --- a/server/server_channel.cc +++ b/server/server_channel.cc @@ -25,8 +25,48 @@ static absl::StatusOr CreateSharedMemory(int id, const char *suffix, toolbelt::FileDescriptor &fd, [[maybe_unused]] int session_id = 0) { char shm_file[NAME_MAX]; // Unique file in file system. - char *shm_name; // Name passed to shm_* (starts with /) int tmpfd; + +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + // On Android, /dev/shm does not exist and shm_open is not usable for + // cross-process named memory. Use regular files in a tmpfs-backed + // directory; the fd is passed to clients via SCM_RIGHTS. + const std::string &shm_dir = GetAndroidShmDir(); + snprintf(shm_file, sizeof(shm_file), "%s/%d.%s.XXXXXX", shm_dir.c_str(), id, + suffix); + tmpfd = mkstemp(shm_file); + if (tmpfd == -1) { + return absl::InternalError(absl::StrFormat( + "Failed to create temp file %s: %s", shm_file, strerror(errno))); + } + + int e = ftruncate(tmpfd, size); + if (e == -1) { + unlink(shm_file); + close(tmpfd); + return absl::InternalError( + absl::StrFormat("Failed to set length of shared memory %s: %s", + shm_file, strerror(errno))); + } + + void *p = nullptr; + if (map) { + p = MapMemory(tmpfd, size, PROT_READ | PROT_WRITE, suffix); + if (p == MAP_FAILED) { + unlink(shm_file); + close(tmpfd); + return absl::InternalError(absl::StrFormat( + "Failed to map shared memory %s: %s", shm_file, strerror(errno))); + } + } + + // Unlink immediately; the fd remains valid for mmap and SCM_RIGHTS passing. + unlink(shm_file); + fd.SetFd(tmpfd); + return p; + +#else + char *shm_name; // Name passed to shm_* (starts with /) #if defined(__linux__) // On Linux we have actual files in /dev/shm so we can create a unique file. snprintf(shm_file, sizeof(shm_file), "/dev/shm/%d.%s.XXXXXX", id, suffix); @@ -76,6 +116,7 @@ static absl::StatusOr CreateSharedMemory(int id, const char *suffix, fd.SetFd(shm_fd); (void)close(tmpfd); return p; +#endif } absl::StatusOr @@ -161,7 +202,12 @@ void ServerChannel::RemoveBuffer(uint64_t session_id, Server *server) { } } if (!plugin_freed && !metadata.object_name.empty()) { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + std::string path = GetAndroidShmDir() + "/" + metadata.object_name; + (void)unlink(path.c_str()); +#else (void)shm_unlink(metadata.object_name.c_str()); +#endif } if (!metadata.shadow_file.empty()) { (void)remove(metadata.shadow_file.c_str()); @@ -173,6 +219,8 @@ void ServerChannel::RemoveBuffer(uint64_t session_id, Server *server) { (void)shm_unlink(shm_name->c_str()); } remove(filename.c_str()); +#elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + (void)unlink(filename.c_str()); #else (void)shm_unlink(filename.c_str()); #endif diff --git a/server/server_channel.h b/server/server_channel.h index 29a511b..62bb58f 100644 --- a/server/server_channel.h +++ b/server/server_channel.h @@ -113,7 +113,7 @@ class PublisherUser : public User { } absl::Status AllocateRetirementFd() { -#if defined(__linux__) +#if defined(__linux__) && !defined(__ANDROID__) auto p = toolbelt::Pipe::CreateWithFlags(O_DIRECT); #else auto p = toolbelt::Pipe::Create(); diff --git a/shadow/BUILD.bazel b/shadow/BUILD.bazel index 8f886df..d64f469 100644 --- a/shadow/BUILD.bazel +++ b/shadow/BUILD.bazel @@ -36,6 +36,7 @@ cc_binary( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], + "//:android": ["-llog"], "//conditions:default": ["-lrt"], }), ) @@ -62,6 +63,7 @@ cc_test( "//:macos_x86_64": [], "//:macos_arm64": [], "//:macos_default": [], + "//:android": ["-llog", "-ldl"], "//conditions:default": ["-lrt", "-ldl"], }), ) diff --git a/shadow/CMakeLists.txt b/shadow/CMakeLists.txt index 8954665..35ea280 100644 --- a/shadow/CMakeLists.txt +++ b/shadow/CMakeLists.txt @@ -30,7 +30,7 @@ target_link_libraries(subspace_shadow PUBLIC absl::flags_parse ) -if(NOT APPLE) +if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT ANDROID) target_link_libraries(subspace_shadow PRIVATE rt) endif() @@ -47,6 +47,6 @@ target_link_libraries(shadow_test PUBLIC absl::status_matchers ) -if(NOT APPLE) +if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT ANDROID) target_link_libraries(shadow_test PRIVATE rt dl) endif()