diff --git a/.bazelrc b/.bazelrc index 9ae2f33..39528cc 100644 --- a/.bazelrc +++ b/.bazelrc @@ -42,6 +42,7 @@ build:macos_x86_64 --extra_execution_platforms=//platform/host:darwin_x86_64 # For all builds, use C++17 build --cxxopt="-std=c++17" +build --java_runtime_version=remotejdk_17 # Statically link C++ deps into Rust binaries (avoids RPATH issues) build --@rules_rust//rust/settings:experimental_use_cc_common_link=True @@ -97,6 +98,10 @@ build:android_arm64 --cpu=aarch64 build:android_arm64 --linkopt=-lc++_static build:android_arm64 --linkopt=-lc++abi build:android_arm64 --extra_toolchains=@androidndk//:all +# Abseil strips flag names on Android by default (ABSL_FLAGS_STRIP_NAMES=1), +# which breaks parsing flags by name (e.g. --socket) on the command line even +# though GetFlag() still works. Keep the names so server/tool flags work. +build:android_arm64 --copt=-DABSL_FLAGS_STRIP_NAMES=0 build:android_x86_64 --platforms=//platform/android:android_x86_64 build:android_x86_64 --action_env=ANDROID_NDK_HOME @@ -105,6 +110,8 @@ 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 +# See android_arm64 note above. +build:android_x86_64 --copt=-DABSL_FLAGS_STRIP_NAMES=0 build:android --config=android_arm64 diff --git a/.cursor/skills/subspace-builds/SKILL.md b/.cursor/skills/subspace-builds/SKILL.md new file mode 100644 index 0000000..a9444f2 --- /dev/null +++ b/.cursor/skills/subspace-builds/SKILL.md @@ -0,0 +1,144 @@ +--- +name: subspace-builds +description: Build and test Subspace across supported platforms and build systems. Use when the user asks how to build, test, cross-compile, run CI-equivalent checks, or work with Bazel, CMake, Android, Soong/Blueprint, AOSP, QNX, Linux, or macOS builds in this repository. +--- + +# Subspace Builds + +## General Rules + +- User-facing examples should use `bazel`; use `bazelisk` as a drop-in + replacement if `bazel` is not available. +- Prefer focused targets while iterating; use `bazel test //...` only when + broad verification is needed. +- Check `.bazelrc`, `.github/workflows/ci.yml`, and `docs/android.md` before changing platform build behavior. +- Do not check in generated protobuf files. + +## Native Host Builds + +Linux: + +```bash +CC=clang bazel build //... +bazel test //... + +cmake -S . -B build/cmake-Debug -DCMAKE_BUILD_TYPE=Debug +cmake --build build/cmake-Debug --parallel +ctest --test-dir build/cmake-Debug --output-on-failure +``` + +macOS Apple Silicon: + +```bash +bazel build //... --config=macos_arm64 +bazel test //... --config=macos_arm64 +``` + +macOS Intel: + +```bash +bazel build //... --config=macos_x86_64 +bazel test //... --config=macos_x86_64 +``` + +## Android With Bazel + +Requires `ANDROID_NDK_HOME`. + +```bash +bazel build \ + //server:subspace_server \ + //client:client_test \ + //c_client:client_test \ + //plugins:nop_plugin.so \ + //plugins:split_buffer_free_test_plugin.so \ + //android/jni:libsubspace_jni.so \ + //android/java:subspace-java \ + //android/java:subspace-java-test \ + --config=android_arm64 +``` + +Use `--config=android_x86_64` for x86_64 emulators and GitHub CI. The emulator +deployment and test flow is in `.github/scripts/android-test.sh`. + +## Android With CMake + +Requires `ANDROID_NDK_HOME`. Build a host `protoc` first and pass it into the +Android cross-compile so protobuf versions match: + +```bash +cmake -S . -B build/host-protoc -DCMAKE_BUILD_TYPE=Release +cmake --build build/host-protoc --target protoc --parallel + +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 \ + -DPROTOC_EXECUTABLE="$PWD/build/host-protoc/_deps/protobuf-build/protoc" + +cmake --build build/android --parallel +``` + +Use `-DANDROID_ABI=x86_64` for x86_64 emulators and GitHub CI. The emulator +deployment and test flow is in `.github/scripts/cmake-android-test.sh`. + +## Android With Soong/Blueprint + +Soong requires a full AOSP checkout; GitHub-hosted runners do not provide one. +Use a local AOSP tree or a self-hosted runner with AOSP already synced. + +Place this repository at `external/subspace`, ensure `external/coroutines` and +`external/cpp_toolbelt` are present, and copy their repository-provided +`Android.bp.example` files to `Android.bp`. + +Add to the product: + +```make +PRODUCT_SOONG_NAMESPACES += external/subspace +PRODUCT_PACKAGES += \ + subspace_server \ + libsubspace_client \ + libsubspace_jni \ + subspace-java \ + subspace_java_client_test +``` + +Build from AOSP root: + +```bash +source build/envsetup.sh +lunch -userdebug + +m external.subspace-subspace_server-soong \ + external.subspace-libsubspace_client-soong \ + external.subspace-libsubspace_jni-soong \ + external.subspace-subspace-java-soong \ + external.subspace-subspace_java_client_test-soong +``` + +Run the device-side Java integration test: + +```bash +adb shell subspace_java_client_test +``` + +## QNX With Bazel + +Requires the QNX SDP and `QNX_SDP_PATH`. + +```bash +bazel build //... --config=qnx_aarch64 +bazel build //... --config=qnx_x86_64 +``` + +If the default path in `.bazelrc` is wrong, set `QNX_SDP_PATH` in the +environment or user-local `user.bazelrc`. + +## References + +- Android details: `docs/android.md` +- General Bazel/CMake docs: `README.md` +- CI build matrix: `.github/workflows/ci.yml` +- Test runner rule: `.cursor/rules/test-runner.mdc` diff --git a/.cursor/skills/subspace-clients/SKILL.md b/.cursor/skills/subspace-clients/SKILL.md new file mode 100644 index 0000000..ad4e975 --- /dev/null +++ b/.cursor/skills/subspace-clients/SKILL.md @@ -0,0 +1,263 @@ +--- +name: subspace-clients +description: Write Subspace clients in C++, Python, Rust, or Java. Use when the user asks how to connect to Subspace, create publishers or subscribers, publish messages, read messages, or build language client libraries with Bazel, CMake, or Android Soong/Blueprint. +--- + +# Subspace Clients + +## Core Model + +- A `subspace_server` process must be running before clients connect. +- Non-Android default socket: `/tmp/subspace`. +- Android default socket: `/data/local/tmp/subspace`. +- A publisher creates a channel with a slot size and slot count, writes into a + shared-memory message buffer, then publishes the written byte count. +- A subscriber attaches to a channel, waits or polls for data, then reads until + the API reports no more messages. +- User-facing build examples use `bazel`; `bazelisk` is a drop-in replacement + when `bazel` is not available. + +## C++ Client + +Include `client/client.h` and link `//client:subspace_client` or the CMake +`subspace_client` target. + +Use a `subspace::Client` when one process needs to create multiple publishers +or subscribers that share one server connection. If the publisher or subscriber +can own its own connection, use the convenience free functions: + +```cpp +auto pub_or = subspace::CreatePublisher( + "example", subspace::PublisherOptions().SetSlotSize(256).SetNumSlots(8), + "/tmp/subspace", "cpp-publisher"); + +auto sub_or = subspace::CreateSubscriber( + "example", subspace::SubscriberOptions(), "/tmp/subspace", + "cpp-subscriber"); +``` + +Publish: + +```cpp +#include "client/client.h" +#include + +subspace::Client client; +auto status = client.Init("/tmp/subspace", "cpp-publisher"); +if (!status.ok()) throw std::runtime_error(status.ToString()); + +auto pub_or = client.CreatePublisher("example", 256, 8); +if (!pub_or.ok()) throw std::runtime_error(pub_or.status().ToString()); +subspace::Publisher pub = *std::move(pub_or); + +auto buffer_or = pub.GetMessageBuffer(); +if (!buffer_or.ok() || *buffer_or == nullptr) { + throw std::runtime_error("no publisher buffer available"); +} + +const char payload[] = "hello from cpp"; +std::memcpy(*buffer_or, payload, sizeof(payload) - 1); +auto msg_or = pub.PublishMessage(sizeof(payload) - 1); +if (!msg_or.ok()) throw std::runtime_error(msg_or.status().ToString()); +``` + +Subscribe: + +```cpp +subspace::Client client; +auto status = client.Init("/tmp/subspace", "cpp-subscriber"); +if (!status.ok()) throw std::runtime_error(status.ToString()); + +auto sub_or = client.CreateSubscriber("example"); +if (!sub_or.ok()) throw std::runtime_error(sub_or.status().ToString()); +subspace::Subscriber sub = *std::move(sub_or); + +status = sub.Wait(); +if (!status.ok()) throw std::runtime_error(status.ToString()); + +for (;;) { + auto msg_or = sub.ReadMessage(); + if (!msg_or.ok()) throw std::runtime_error(msg_or.status().ToString()); + if (msg_or->length == 0) break; + auto bytes = static_cast(msg_or->buffer); + // Process bytes[0..msg_or->length). +} +``` + +## Python Client + +The Python binding is `client.python.subspace`. The server binding used by +tests is `server.python.subspace_server`. + +```python +import client.python.subspace as subspace + +client = subspace.Client() +client.init(server_socket="/tmp/subspace", client_name="python-client") + +publisher = client.create_publisher( + channel_name="example", slot_size=256, num_slots=8 +) +subscriber = client.create_subscriber(channel_name="example") + +publisher.publish_message(b"hello from python") +subscriber.wait() + +while True: + data = subscriber.read_message() + if len(data) == 0: + break + # Process data as bytes. +``` + +For message metadata and ordinals, use `read_message_object()`: + +```python +with subscriber.read_message_object() as msg: + print(msg.ordinal, msg.timestamp, msg.buffer) +``` + +## Rust Client + +The Rust crate name is `subspace_client`. + +```rust +use subspace_client::{Client, PublisherOptions, ReadMode, SubscriberOptions}; + +let client = Client::new("/tmp/subspace", "rust-client").unwrap(); + +let pub_opts = PublisherOptions::new() + .set_slot_size(256) + .set_num_slots(8); +let publisher = client.create_publisher("example", &pub_opts).unwrap(); + +let payload = b"hello from rust"; +let (buf_ptr, _capacity) = publisher + .get_message_buffer(payload.len() as i64) + .unwrap() + .unwrap(); +unsafe { + std::ptr::copy_nonoverlapping(payload.as_ptr(), buf_ptr, payload.len()); +} +publisher.publish_message(payload.len() as i64).unwrap(); + +let sub_opts = SubscriberOptions::new(); +let subscriber = client.create_subscriber("example", &sub_opts).unwrap(); +subscriber.wait(Some(5000)).unwrap(); + +loop { + let msg = subscriber.read_message(ReadMode::ReadNext).unwrap(); + if msg.is_empty() { + break; + } + let data = unsafe { msg.as_slice() }; + // Process data. +} +``` + +## Java Client + +The Java client is Android-focused and uses JNI. Load `libsubspace_jni.so` +normally via `System.loadLibrary("subspace_jni")`; device-side tests may preload +native libraries with absolute paths when using `/data/local/tmp`. + +```java +import com.subspace.SubspaceClient; +import com.subspace.SubspaceMessage; +import com.subspace.SubspacePublisher; +import com.subspace.SubspaceSubscriber; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; + +byte[] payload = "hello from java".getBytes(StandardCharsets.UTF_8); + +try (SubspaceClient client = + new SubspaceClient("/data/local/tmp/subspace", "java-client"); + SubspacePublisher publisher = + client.createPublisher("/example", 256, 8); + SubspaceSubscriber subscriber = + client.createSubscriber("/example")) { + + ByteBuffer buffer = publisher.getMessageBuffer(payload.length); + if (buffer == null) { + throw new IllegalStateException("no publisher buffer available"); + } + buffer.put(payload); + publisher.publishMessage(payload.length); + + SubspaceMessage message = subscriber.readMessage(); + if (message != null) { + ByteBuffer data = message.getData(); + // Process data[0..message.getLength()). + } +} +``` + +## Build The Clients + +C++: + +```bash +bazel build //client:subspace_client +cmake -S . -B build/cmake-Debug -DCMAKE_BUILD_TYPE=Debug +cmake --build build/cmake-Debug --target subspace_client +``` + +Python: + +```bash +bazel build //client/python:subspace +bazel test //client/python:client_test + +cmake -S . -B build/cmake-Debug -DCMAKE_BUILD_TYPE=Debug +cmake --build build/cmake-Debug --target subspace +``` + +Rust: + +```bash +bazel build //rust_client:subspace_client_rust +bazel test //rust_client:client_test + +cmake -S . -B build/cmake-Debug -DCMAKE_BUILD_TYPE=Debug +cmake --build build/cmake-Debug --target subspace_client_rust + +cd rust_client && cargo build && cargo test -- --test-threads=1 +``` + +Java/JNI for Android: + +```bash +bazel build \ + //android/jni:libsubspace_jni.so \ + //android/java:subspace-java \ + //android/java:subspace-java-test \ + --config=android_x86_64 + +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 \ + -DPROTOC_EXECUTABLE=/path/to/matching/host/protoc +cmake --build build/android --target subspace_jni subspace_java subspace_java_test +``` + +Soong/Blueprint in AOSP: + +```bash +m external.subspace-libsubspace_client-soong \ + external.subspace-libsubspace_jni-soong \ + external.subspace-subspace-java-soong \ + external.subspace-subspace_java_client_test-soong +``` + +## References + +- C++ API: `client/client.h` +- Python examples: `client/python/client_test.py` +- Rust guide: `docs/rust-client.md` +- Java API: `android/java/com/subspace/*.java` +- Android build/run details: `docs/android.md` +- Platform build skill: `.cursor/skills/subspace-builds/SKILL.md` diff --git a/.github/scripts/android-test.sh b/.github/scripts/android-test.sh index e6bf59d..4304869 100755 --- a/.github/scripts/android-test.sh +++ b/.github/scripts/android-test.sh @@ -8,16 +8,17 @@ 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) +rm -rf /tmp/android_libs 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 +cp -L bazel-bin/android/jni/libsubspace_jni.so /tmp/android_libs/ 2>/dev/null || true if ls /tmp/android_libs/*.so 1>/dev/null 2>&1; then + adb shell "rm -rf /data/local/tmp/android_libs" adb push /tmp/android_libs /data/local/tmp/android_libs fi @@ -38,9 +39,27 @@ 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 +SDK_ROOT="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-/usr/local/lib/android/sdk}}" +BUILD_TOOLS_VERSION=$(ls "$SDK_ROOT/build-tools" | sort -V | tail -1) +D8="$SDK_ROOT/build-tools/$BUILD_TOOLS_VERSION/d8" +PLATFORM_VERSION=$(ls "$SDK_ROOT/platforms" | sort -V | tail -1) +ANDROID_JAR="$SDK_ROOT/platforms/$PLATFORM_VERSION/android.jar" +rm -rf /tmp/subspace_java_test_dex +mkdir -p /tmp/subspace_java_test_dex +"$D8" --lib "$ANDROID_JAR" --output /tmp/subspace_java_test_dex \ + bazel-bin/android/java/libsubspace-java.jar \ + bazel-bin/android/java/libsubspace-java-test.jar +(cd /tmp/subspace_java_test_dex && zip -q -r /tmp/subspace-java-test-dex.jar classes.dex) +adb push /tmp/subspace-java-test-dex.jar /data/local/tmp/subspace-java-test.jar + +# Push plugin .so files to relative path expected by tests. Remove the target +# directory first so an old directory named nop_plugin.so cannot shadow the file. +rm -rf /tmp/android_plugins +mkdir -p /tmp/android_plugins +cp -L bazel-bin/plugins/nop_plugin.so /tmp/android_plugins/ +cp -L bazel-bin/plugins/split_buffer_free_test_plugin.so /tmp/android_plugins/ +adb shell "rm -rf /data/local/tmp/plugins" +adb push /tmp/android_plugins /data/local/tmp/plugins # Make binaries executable adb shell "chmod +x /data/local/tmp/*_test /data/local/tmp/subspace_server" @@ -69,4 +88,7 @@ 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 "=== subspace-java integration test ===" +adb shell "cd /data/local/tmp && $LIB dalvikvm -cp /data/local/tmp/subspace-java-test.jar com.subspace.test.SubspaceJavaClientTest" + echo "=== All Android tests passed ===" diff --git a/.github/scripts/cmake-android-test.sh b/.github/scripts/cmake-android-test.sh index 189ee67..a13ab57 100755 --- a/.github/scripts/cmake-android-test.sh +++ b/.github/scripts/cmake-android-test.sh @@ -10,8 +10,6 @@ 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) @@ -29,6 +27,20 @@ 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 +adb push "$BUILD_DIR/android/libsubspace_jni.so" /data/local/tmp/libsubspace_jni.so + +SDK_ROOT="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-/usr/local/lib/android/sdk}}" +BUILD_TOOLS_VERSION=$(ls "$SDK_ROOT/build-tools" | sort -V | tail -1) +D8="$SDK_ROOT/build-tools/$BUILD_TOOLS_VERSION/d8" +PLATFORM_VERSION=$(ls "$SDK_ROOT/platforms" | sort -V | tail -1) +ANDROID_JAR="$SDK_ROOT/platforms/$PLATFORM_VERSION/android.jar" +rm -rf /tmp/subspace_cmake_java_test_dex +mkdir -p /tmp/subspace_cmake_java_test_dex +"$D8" --lib "$ANDROID_JAR" --output /tmp/subspace_cmake_java_test_dex \ + "$BUILD_DIR/android/subspace-java.jar" \ + "$BUILD_DIR/android/subspace-java-test.jar" +(cd /tmp/subspace_cmake_java_test_dex && zip -q -r /tmp/subspace-cmake-java-test-dex.jar classes.dex) +adb push /tmp/subspace-cmake-java-test-dex.jar /data/local/tmp/subspace-java-test.jar # Push plugin .so files adb shell "mkdir -p /data/local/tmp/plugins" @@ -53,4 +65,7 @@ adb shell "cd /data/local/tmp && $LIB ./c_client_test" echo "=== shadow_test ===" adb shell "cd /data/local/tmp && $LIB ./shadow_test" +echo "=== subspace-java integration test ===" +adb shell "cd /data/local/tmp && $LIB dalvikvm -cp /data/local/tmp/subspace-java-test.jar com.subspace.test.SubspaceJavaClientTest" + echo "=== All CMake Android tests passed ===" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 61600bb..043ce98 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -279,6 +279,11 @@ jobs: - name: Set up Android NDK run: echo "ANDROID_NDK_HOME=$ANDROID_NDK_LATEST_HOME" >> $GITHUB_ENV + - name: Build host protoc for cross-compilation + run: | + cmake -S . -B build/host-protoc -DCMAKE_BUILD_TYPE=Release + cmake --build build/host-protoc --target protoc --parallel $(nproc) + - name: Configure CMake for Android x86_64 run: | cmake -S . -B build/android \ @@ -286,7 +291,8 @@ jobs: -DANDROID_ABI=x86_64 \ -DANDROID_PLATFORM=android-28 \ -DANDROID_STL=c++_shared \ - -DCMAKE_BUILD_TYPE=Release + -DCMAKE_BUILD_TYPE=Release \ + -DPROTOC_EXECUTABLE="$PWD/build/host-protoc/_deps/protobuf-build/protoc" - name: Build run: cmake --build build/android --parallel $(nproc) @@ -339,6 +345,9 @@ jobs: //common:split_buffer_test \ //plugins:nop_plugin.so \ //plugins:split_buffer_free_test_plugin.so \ + //android/jni:libsubspace_jni.so \ + //android/java:subspace-java \ + //android/java:subspace-java-test \ //coro_rpc/test:rpc_test \ //coro_rpc/server:server_test \ //coro_rpc/client:client_test \ diff --git a/.gitignore b/.gitignore index 5b4e390..a4d56ae 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,5 @@ build rust_client/target rust_rpc/target user.bazelrc +proto/*.pb.cc +proto/*.pb.h diff --git a/Android.bp b/Android.bp index 7f08d1d..1fcbc9f 100644 --- a/Android.bp +++ b/Android.bp @@ -2,6 +2,8 @@ // All Rights Reserved // See LICENSE file for licensing information. +soong_namespace {} + // Common defaults for all subspace native modules. cc_defaults { name: "subspace_defaults", @@ -9,6 +11,7 @@ cc_defaults { "-std=c++17", "-Wall", "-Wextra", + "-Wno-sign-compare", "-Wno-missing-field-initializers", "-Wno-unused-parameter", ], @@ -17,7 +20,27 @@ cc_defaults { cflags: ["-DSUBSPACE_ANDROID"], }, }, + cppflags: ["-fexceptions"], local_include_dirs: ["."], + include_dirs: ["external/subspace"], + rtti: true, stl: "c++_shared", min_sdk_version: "28", + compile_multilib: "64", +} + +// Generate C++ protobuf sources from subspace.proto. +cc_library_static { + name: "libsubspace_proto", + defaults: ["subspace_defaults"], + srcs: ["proto/subspace.proto"], + proto: { + type: "full", + canonical_path_from_root: false, + include_dirs: ["external/protobuf/src"], + export_proto_headers: true, + }, + shared_libs: ["libprotobuf-cpp-full"], + export_shared_lib_headers: ["libprotobuf-cpp-full"], + rtti: false, } diff --git a/CMakeLists.txt b/CMakeLists.txt index 289667b..8e27dd5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,7 @@ set(protobuf_BUILD_TESTS OFF CACHE INTERNAL "No protobuf tests") set(ABSL_BUILD_TEST_HELPERS ON CACHE INTERNAL "Enable Abseil TESTONLY+PUBLIC helpers (e.g. status_matchers)") 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") +set(SUBSPACE_PROTOBUF_VERSION 29.5) # When cross-compiling, don't build protoc (we use a host-native one). if(CMAKE_CROSSCOMPILING) @@ -106,7 +107,7 @@ FetchContent_MakeAvailable(cpp_toolbelt) FetchContent_Declare( protobuf GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git - GIT_TAG v29.5 + GIT_TAG v${SUBSPACE_PROTOBUF_VERSION} CMAKE_ARGS -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_BUILD_EXAMPLES=OFF @@ -151,6 +152,7 @@ add_subdirectory(server) add_subdirectory(plugins) add_subdirectory(shadow) add_subdirectory(c_client) +add_subdirectory(android) add_subdirectory(rust_client) if(TARGET client_test AND TARGET nop_plugin) diff --git a/MODULE.bazel b/MODULE.bazel index 93b3777..11d11d1 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -10,6 +10,7 @@ bazel_dep(name = "googletest", version = "1.17.0") bazel_dep(name = "protobuf", version = "33.2") bazel_dep(name = "rules_cc", version = "0.2.17") +bazel_dep(name = "rules_java", version = "9.1.0") 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") diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 835ce52..ed1abf9 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -327,7 +327,7 @@ "@@rules_android_ndk+//:extension.bzl%android_ndk_repository_extension": { "general": { "bzlTransitiveDigest": "j+NMXk5/a1vnDypModKL+ToEo/4o7DJeXSFhTfbJ7rI=", - "usagesDigest": "TItR9CHlQeATFb93dsFSm1Q0KP5bwlwGGfzE10p5D/c=", + "usagesDigest": "Dshe+RJHb2CHJNFJG53h45menXtSyF3M1AMuHpTXiGU=", "recordedInputs": [], "generatedRepoSpecs": { "androidndk": { @@ -595,7 +595,7 @@ "@@rules_rust+//crate_universe:extensions.bzl%crate": { "general": { "bzlTransitiveDigest": "KnoFc60aLWU0GPkk2YxX0MzTPpyFIWzv8bMO30Tfq6E=", - "usagesDigest": "KyvZKPfBv/dV/uHvW4yR1BO9VzoALFef2zQ8yx7/fws=", + "usagesDigest": "/BgLa1QXl04f1VN+daWFRiA9R2aF6eCMLnYpzYfQsgU=", "recordedInputs": [ "ENV:CARGO_BAZEL_DEBUG \\0", "ENV:CARGO_BAZEL_GENERATOR_SHA256 \\0", diff --git a/README.md b/README.md index db7a728..7f41dee 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ It has the following features: 1. Ability to read the next or newest message in a channel. 1. File-descriptor-based event triggers. 1. Optional split payload buffers for external allocators and memory pools. -1. Automatic UDP discovery and TCP bridging of channels between servers. +1. Automatic UDP discovery and TCP bridging of channels between servers, plus optional TCP unicast discovery for bridging across NAT/VMs/emulators. 1. Shadow process for crash recovery -- the server can restart and resume without losing shared memory state. 1. Shared and weak pointers for message references. 1. Ports to MacOS, Linux, QNX and Android, for ARM64 and x86_64. @@ -45,10 +45,11 @@ See the file docs/subspace.pdf for full documentation. Additional documentation - [Server Architecture](docs/server-architecture.md) - [Rust Client](docs/rust-client.md) - [Shadow Process (Crash Recovery)](docs/shadow-process.md) +- [Running Subspace on Android](docs/android.md) # Building -Subspace can be built using either Bazel or CMake. Both build systems will automatically download and build all required dependencies. +Subspace can be built using Bazel or CMake. Android platform integrations can also be built with Soong/Blueprint inside an AOSP tree; see [Running Subspace on Android](docs/android.md). ## Building with Bazel @@ -1654,6 +1655,71 @@ scheduler.Run(); When using coroutines, `Wait()` operations will yield instead of blocking the thread. +## Cross-Computer Bridging and Discovery + +A channel published on one server can be transparently mirrored to subscribers +on another server. Servers find each other through *discovery*, then move +message data over a TCP *bridge*. Discovery is only active when the server is +**not** started with `--local`, and a channel is only bridged when its +publisher is created with `local = false` (`PublisherOptions::SetLocal(false)`). + +### Discovery modes + +| Mode | How to enable | When to use | +|------|---------------|-------------| +| UDP broadcast (default) | nothing extra | Servers on the same LAN/subnet; zero configuration. | +| UDP unicast | `--peer_address=HOST` | A specific peer is known but broadcast is undesirable/unavailable. | +| TCP unicast | `--tcp_discovery` | Peers that cannot exchange UDP datagrams directly, e.g. across a NAT, a VM, or an Android emulator. | + +Common discovery/bridge flags: + +| Flag | Default | Description | +|------|---------|-------------| +| `--local` | `false` | Disable all network discovery/bridging (local machine only). | +| `--disc_port` | `6502` | Discovery port (UDP, or TCP listen port with `--tcp_discovery`). | +| `--peer_port` | `6502` | Peer discovery port to send/connect to. | +| `--peer_address` | `""` | Peer host/IP. Unicast UDP, or the dial target with `--tcp_discovery`. | +| `--interface` | `""` | Network interface for discovery (auto-detected if empty). | +| `--tcp_discovery` | `false` | Run discovery over a single TCP connection instead of UDP. | +| `--bridge_advertise_address` | `""` | Address to advertise for this server's bridge listeners (e.g. `127.0.0.1` for a forwarded loopback endpoint). | +| `--bridge_ports` | `""` | Fixed TCP bridge port or inclusive range `START-END` (default: ephemeral per bridge). | + +### TCP unicast discovery (across NAT / VMs / emulators) + +UDP discovery assumes peers can exchange datagrams directly and be reached on +the port they advertise. That fails behind a NAT (such as an Android emulator), +where only one side can initiate connections. With `--tcp_discovery` the +handshake runs over a single TCP connection: + +- the server **with** `--peer_address` set **dials** the peer's `--disc_port`; +- the server **without** one **listens** on `--disc_port`. + +Because only the dialing (NAT'd) side needs to reach the other, this works +where UDP cannot. When a server's listeners are only reachable through a +forwarded loopback port (e.g. an `adb forward`/`adb reverse` tunnel), add +`--bridge_advertise_address=127.0.0.1` so it advertises that endpoint and binds +its bridge listeners to the any-address. See +[Server Architecture](docs/server-architecture.md) and, for the emulator case, +[Running Subspace on Android](docs/android.md). + +### Manual cross-computer test + +`manual_tests/cross_host_bridge.sh` brings up two servers and bridges a channel +in **both** directions (publish on A / subscribe on B and vice versa), then +checks that messages arrive: + +```bash +# Two servers on this host over loopback (validates the TCP discovery path): +manual_tests/cross_host_bridge.sh native + +# This host bridged to a running Android emulator (sets up the adb tunnels): +manual_tests/cross_host_bridge.sh emulator +``` + +The `manual_tests/pub` tool takes `--local=false` and `--channel=NAME`, and +`manual_tests/sub` takes `--channel=NAME`, so you can also drive bridging by +hand against servers on two different computers. + ## Shadow Server (Crash Recovery) Subspace supports a **shadow process** that mirrors the server's channel, diff --git a/android/Android.bp b/android/Android.bp index 0a2d076..03c8623 100644 --- a/android/Android.bp +++ b/android/Android.bp @@ -7,7 +7,7 @@ cc_library_shared { name: "libsubspace_jni", defaults: ["subspace_defaults"], srcs: ["jni/subspace_jni.cc"], - local_include_dirs: [".."], + include_dirs: ["external/subspace"], shared_libs: [ "libsubspace_client", "liblog", @@ -17,10 +17,10 @@ cc_library_shared { "libsubspace_proto", "libcoroutines", "libcpp_toolbelt", + "libabsl", ], header_libs: [ "jni_headers", - "libabseil-headers", ], } @@ -30,4 +30,17 @@ java_library { srcs: ["java/com/subspace/*.java"], required: ["libsubspace_jni"], sdk_version: "current", + min_sdk_version: "28", +} + +// Device-side integration test for the Java/JNI client. +java_binary { + name: "subspace_java_client_test", + srcs: ["java/com/subspace/test/*.java"], + wrapper: "java/subspace_java_client_test.sh", + static_libs: ["subspace-java"], + jni_libs: ["libsubspace_jni"], + required: ["subspace_server"], + sdk_version: "current", + min_sdk_version: "28", } diff --git a/android/CMakeLists.txt b/android/CMakeLists.txt new file mode 100644 index 0000000..aa1189b --- /dev/null +++ b/android/CMakeLists.txt @@ -0,0 +1,46 @@ +# Copyright 2026 General Motors Inc. +# All Rights Reserved +# See LICENSE file for licensing information. + +# Java wrapper for Android clients. The classes use JNI but do not depend on +# Android SDK APIs, so they can be compiled with the host Java toolchain. + +find_package(Java COMPONENTS Development QUIET) + +if(Java_FOUND) + include(UseJava) + + file(GLOB SUBSPACE_JAVA_SOURCES CONFIGURE_DEPENDS + "${CMAKE_CURRENT_SOURCE_DIR}/java/com/subspace/*.java" + ) + + add_jar(subspace_java + SOURCES ${SUBSPACE_JAVA_SOURCES} + OUTPUT_NAME subspace-java + ) + + file(GLOB SUBSPACE_JAVA_TEST_SOURCES CONFIGURE_DEPENDS + "${CMAKE_CURRENT_SOURCE_DIR}/java/com/subspace/test/*.java" + ) + + add_jar(subspace_java_test + SOURCES ${SUBSPACE_JAVA_TEST_SOURCES} + INCLUDE_JARS subspace_java + ENTRY_POINT com.subspace.test.SubspaceJavaClientTest + OUTPUT_NAME subspace-java-test + ) +else() + message(STATUS "Java development tools not found; skipping subspace_java") +endif() + +if(ANDROID) + add_library(subspace_jni SHARED + jni/subspace_jni.cc + ) + + target_link_libraries(subspace_jni PRIVATE + subspace_client + subspace_common + log + ) +endif() diff --git a/android/java/BUILD.bazel b/android/java/BUILD.bazel new file mode 100644 index 0000000..d8c0263 --- /dev/null +++ b/android/java/BUILD.bazel @@ -0,0 +1,18 @@ +# Copyright 2026 General Motors Inc. +# All Rights Reserved +# See LICENSE file for licensing information. + +package(default_visibility = ["//visibility:public"]) + +load("@rules_java//java:defs.bzl", "java_library") + +java_library( + name = "subspace-java", + srcs = glob(["com/subspace/*.java"]), +) + +java_library( + name = "subspace-java-test", + srcs = glob(["com/subspace/test/*.java"]), + deps = [":subspace-java"], +) diff --git a/android/java/com/subspace/test/SubspaceJavaClientTest.java b/android/java/com/subspace/test/SubspaceJavaClientTest.java new file mode 100644 index 0000000..a828b19 --- /dev/null +++ b/android/java/com/subspace/test/SubspaceJavaClientTest.java @@ -0,0 +1,195 @@ +// Copyright 2026 General Motors Inc. +// All Rights Reserved +// See LICENSE file for licensing information. + +package com.subspace.test; + +import com.subspace.SubspaceClient; +import com.subspace.SubspaceException; +import com.subspace.SubspaceMessage; +import com.subspace.SubspacePublisher; +import com.subspace.SubspaceSubscriber; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +public final class SubspaceJavaClientTest { + private static final String WORK_DIR = getEnv("SUBSPACE_TEST_WORK_DIR", "/data/local/tmp"); + private static final String SERVER = getEnv("SUBSPACE_SERVER", WORK_DIR + "/subspace_server"); + private static final String SOCKET = getEnv("SUBSPACE_SOCKET", WORK_DIR + "/subspace"); + private static final String NATIVE_LIB_DIR = + getEnv("SUBSPACE_NATIVE_LIB_DIR", WORK_DIR + "/android_libs"); + private static final String LIB_PATH = + getEnv("SUBSPACE_LD_LIBRARY_PATH", NATIVE_LIB_DIR + ":" + WORK_DIR); + private static final long SERVER_TIMEOUT_MS = 10_000; + private static final long MESSAGE_TIMEOUT_MS = 5_000; + + private SubspaceJavaClientTest() {} + + private static String getEnv(String name, String defaultValue) { + String value = System.getenv(name); + return value == null || value.isEmpty() ? defaultValue : value; + } + + public static void main(String[] args) throws Exception { + Process server = null; + try { + preloadNativeLibraries(); + deleteSocket(); + server = startServer(); + waitForServer(); + + testPublishSubscribe(); + testCancelPublish(); + + System.out.println("SubspaceJavaClientTest passed"); + } finally { + stopServer(server); + deleteSocket(); + } + } + + private static void preloadNativeLibraries() { + loadIfPresent("libc++.so"); + loadIfPresent("libprotobuf-cpp-full.so"); + loadIfPresent("libsubspace_client.so"); + loadIfPresent("libsubspace_jni.so"); + } + + private static void loadIfPresent(String libraryName) { + File library = new File(NATIVE_LIB_DIR, libraryName); + if (library.exists()) { + System.load(library.getAbsolutePath()); + } + } + + private static Process startServer() throws IOException { + ProcessBuilder builder = new ProcessBuilder(SERVER); + builder.directory(new File(WORK_DIR)); + builder.redirectErrorStream(true); + Map env = builder.environment(); + env.put("LD_LIBRARY_PATH", LIB_PATH); + + Process process = builder.start(); + Thread outputThread = new Thread(() -> copyServerOutput(process), "subspace-server-output"); + outputThread.setDaemon(true); + outputThread.start(); + return process; + } + + private static void copyServerOutput(Process process) { + try (BufferedReader reader = + new BufferedReader(new InputStreamReader(process.getInputStream()))) { + String line; + while ((line = reader.readLine()) != null) { + System.out.println("[subspace_server] " + line); + } + } catch (IOException ignored) { + } + } + + private static void waitForServer() throws Exception { + long deadline = System.currentTimeMillis() + SERVER_TIMEOUT_MS; + SubspaceException lastError = null; + while (System.currentTimeMillis() < deadline) { + try (SubspaceClient ignored = new SubspaceClient(SOCKET, "java-wait")) { + return; + } catch (SubspaceException e) { + lastError = e; + Thread.sleep(100); + } + } + throw new AssertionError("Timed out waiting for subspace_server", lastError); + } + + private static void testPublishSubscribe() throws Exception { + byte[] payload = "hello from java".getBytes(StandardCharsets.UTF_8); + try (SubspaceClient client = new SubspaceClient(SOCKET, "java-test"); + SubspacePublisher publisher = + client.createPublisher("/java/test/pubsub", 128, 4); + SubspaceSubscriber subscriber = + client.createSubscriber("/java/test/pubsub")) { + + ByteBuffer buffer = publisher.getMessageBuffer(payload.length); + assertTrue(buffer != null, "publisher returned null message buffer"); + buffer.put(payload); + long ordinal = publisher.publishMessage(payload.length); + assertTrue(ordinal >= 0, "publish returned negative ordinal"); + + SubspaceMessage message = readMessageEventually(subscriber); + assertEquals(payload.length, message.getLength(), "message length"); + + byte[] actual = new byte[message.getLength()]; + message.getData().get(actual); + assertTrue(Arrays.equals(payload, actual), + "payload mismatch: expected '" + new String(payload, StandardCharsets.UTF_8) + + "' got '" + new String(actual, StandardCharsets.UTF_8) + "'"); + } + } + + private static void testCancelPublish() { + try (SubspaceClient client = new SubspaceClient(SOCKET, "java-cancel"); + SubspacePublisher publisher = + client.createPublisher("/java/test/cancel", 64, 2)) { + ByteBuffer buffer = publisher.getMessageBuffer(16); + assertTrue(buffer != null, "publisher returned null buffer for cancel test"); + buffer.put("cancelled".getBytes(StandardCharsets.UTF_8)); + publisher.cancelPublish(); + } + } + + private static SubspaceMessage readMessageEventually(SubspaceSubscriber subscriber) + throws InterruptedException { + long deadline = System.currentTimeMillis() + MESSAGE_TIMEOUT_MS; + while (System.currentTimeMillis() < deadline) { + SubspaceMessage message = subscriber.readMessage(); + if (message != null) { + return message; + } + Thread.sleep(10); + } + throw new AssertionError("Timed out waiting for published message"); + } + + private static void stopServer(Process server) { + if (server == null) { + return; + } + server.destroy(); + try { + if (!server.waitFor(2, TimeUnit.SECONDS)) { + server.destroyForcibly(); + server.waitFor(2, TimeUnit.SECONDS); + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + server.destroyForcibly(); + } + } + + private static void deleteSocket() { + File socket = new File(SOCKET); + if (socket.exists() && !socket.delete()) { + throw new AssertionError("Failed to delete stale socket " + SOCKET); + } + } + + private static void assertTrue(boolean condition, String message) { + if (!condition) { + throw new AssertionError(message); + } + } + + private static void assertEquals(int expected, int actual, String field) { + if (expected != actual) { + throw new AssertionError(field + ": expected " + expected + " got " + actual); + } + } +} diff --git a/android/java/subspace_java_client_test.sh b/android/java/subspace_java_client_test.sh new file mode 100644 index 0000000..778d19c --- /dev/null +++ b/android/java/subspace_java_client_test.sh @@ -0,0 +1,13 @@ +#!/system/bin/sh + +# Copyright 2026 General Motors Inc. +# All Rights Reserved +# See LICENSE file for licensing information. + +base=/system +export CLASSPATH=$base/framework/subspace_java_client_test.jar +export SUBSPACE_TEST_WORK_DIR=${SUBSPACE_TEST_WORK_DIR:-/data/local/tmp} +export SUBSPACE_SERVER=${SUBSPACE_SERVER:-$base/bin/subspace_server} +export SUBSPACE_SOCKET=${SUBSPACE_SOCKET:-/data/local/tmp/subspace} + +exec app_process $base/bin com.subspace.test.SubspaceJavaClientTest "$@" diff --git a/c_client/client_test.cc b/c_client/client_test.cc index 8f7e57c..3ac5e2b 100644 --- a/c_client/client_test.cc +++ b/c_client/client_test.cc @@ -32,7 +32,11 @@ class ClientTest : public ::testing::Test { // We run one server for the duration of the whole test suite. static void SetUpTestSuite() { printf("Starting Subspace server\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]; @@ -88,7 +92,11 @@ class ClientTest : public ::testing::Test { }; co::CoroutineScheduler ClientTest::scheduler_; +#if defined(__ANDROID__) +std::string ClientTest::socket_ = "/data/local/tmp/subspace"; +#else std::string ClientTest::socket_ = "/tmp/subspace"; +#endif int ClientTest::server_pipe_[2]; std::unique_ptr ClientTest::server_; std::thread ClientTest::server_thread_; diff --git a/client/Android.bp b/client/Android.bp index 7ec7158..01daef2 100644 --- a/client/Android.bp +++ b/client/Android.bp @@ -15,27 +15,16 @@ cc_library_shared { "arm_crc32.S", ], export_include_dirs: ["."], - local_include_dirs: [".."], + include_dirs: ["external/subspace"], static_libs: [ "libsubspace_common", "libsubspace_proto", "libcoroutines", "libcpp_toolbelt", + "libabsl", ], shared_libs: [ - "libprotobuf-cpp-lite", + "libprotobuf-cpp-full", "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/BUILD.bazel b/client/BUILD.bazel index 233e065..8ee0f6d 100644 --- a/client/BUILD.bazel +++ b/client/BUILD.bazel @@ -52,6 +52,7 @@ cc_library( cc_test( name = "client_test", size = "small", + timeout = "moderate", srcs = ["client_test.cc"], data = [ "//server:subspace_server", diff --git a/client/bridge_test.cc b/client/bridge_test.cc index a24bd8e..5b68edb 100644 --- a/client/bridge_test.cc +++ b/client/bridge_test.cc @@ -275,7 +275,7 @@ class ScopedBridgeServerPair { ~ScopedBridgeServerPair() { Stop(); } void Start(const std::array &ranges) { - 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)); @@ -289,7 +289,7 @@ class ScopedBridgeServerPair { } for (int i = 0; i < 2; 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]; diff --git a/client/client.cc b/client/client.cc index 9354723..7bf4747 100644 --- a/client/client.cc +++ b/client/client.cc @@ -20,6 +20,38 @@ namespace subspace { namespace { std::atomic default_use_split_buffers{false}; + +ClientBufferAllocatorKind FromProtoAllocator(ClientBufferAllocator allocator) { + switch (allocator) { + case CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD: + return ClientBufferAllocatorKind::kAndroidMemfd; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM: + return ClientBufferAllocatorKind::kSplitShm; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK: + return ClientBufferAllocatorKind::kSplitCallback; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST: + return ClientBufferAllocatorKind::kSplitBufferFreeTest; + case CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED: + default: + return ClientBufferAllocatorKind::kUnspecified; + } +} + +ClientBufferAllocator ToProtoAllocator(ClientBufferAllocatorKind allocator) { + switch (allocator) { + case ClientBufferAllocatorKind::kAndroidMemfd: + return CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD; + case ClientBufferAllocatorKind::kSplitShm: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM; + case ClientBufferAllocatorKind::kSplitCallback: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK; + case ClientBufferAllocatorKind::kSplitBufferFreeTest: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST; + case ClientBufferAllocatorKind::kUnspecified: + default: + return CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED; + } +} } using ClientChannel = details::ClientChannel; @@ -58,11 +90,24 @@ static void ToProto(const ClientBufferHandleMetadata &metadata, proto->set_handle(static_cast(metadata.handle)); proto->set_shadow_file(metadata.shadow_file); proto->set_object_name(metadata.object_name); - proto->set_allocator(metadata.allocator); - proto->set_pool_id(metadata.pool_id); - proto->set_cache_enabled(metadata.cache_enabled); - proto->set_alignment(metadata.alignment); - *proto->mutable_allocator_metadata() = metadata.allocator_metadata; + proto->set_allocator(ToProtoAllocator(metadata.allocator)); +} + +static ClientBufferHandleMetadata +FromProto(const ClientBufferHandleMetadataProto &proto) { + ClientBufferHandleMetadata metadata; + metadata.channel_name = proto.channel_name(); + metadata.session_id = proto.session_id(); + metadata.buffer_index = proto.buffer_index(); + metadata.slot_id = proto.slot_id(); + metadata.is_prefix = proto.is_prefix(); + metadata.full_size = proto.full_size(); + metadata.allocation_size = proto.allocation_size(); + metadata.handle = static_cast(proto.handle()); + metadata.shadow_file = proto.shadow_file(); + metadata.object_name = proto.object_name(); + metadata.allocator = FromProtoAllocator(proto.allocator()); + return metadata; } ClientImpl::ClientLockGuard::ClientLockGuard(ClientImpl *client, @@ -344,8 +389,14 @@ ClientImpl::CreatePublisher(const std::string &channel_name, }, server_user_id_, server_group_id_); channel->SetClientBufferRegistrationCallback( - [this](const ClientBufferHandleMetadata &metadata) { - return RegisterClientBuffer(metadata); + [this](const ClientBufferHandleMetadata &metadata, + const toolbelt::FileDescriptor *fd) { + return RegisterClientBuffer(metadata, fd); + }); + channel->SetClientBufferLookupCallback( + [this](const std::string &channel_name, uint64_t session_id, + uint32_t buffer_index) { + return GetClientBuffers(channel_name, session_id, buffer_index); }); channel->SetClientBufferUnregistrationCallback( [this](const std::string &channel_name, uint64_t session_id, @@ -458,6 +509,11 @@ ClientImpl::CreateSubscriber(const std::string &channel_name, return CheckReload(static_cast(c)); }, server_user_id_, server_group_id_); + channel->SetClientBufferLookupCallback( + [this](const std::string &channel_name, uint64_t session_id, + uint32_t buffer_index) { + return GetClientBuffers(channel_name, session_id, buffer_index); + }); channel->SetNumSlots(sub_resp.num_slots()); { @@ -1765,7 +1821,8 @@ absl::Status ClientImpl::ReregisterSubscriber(SubscriberImpl *subscriber) { absl::Status ClientImpl::SendRequestReceiveResponse( const Request &req, Response &response, - std::vector &fds) { + std::vector &fds, + const std::vector &send_fds) { { size_t msg_len = req.ByteSizeLong(); @@ -1781,13 +1838,20 @@ absl::Status ClientImpl::SendRequestReceiveResponse( socket_.Close(); if (was_connected_ && !reconnecting_) { if (absl::Status rs = Reconnect(); rs.ok()) { - return SendRequestReceiveResponse(req, response, fds); + return SendRequestReceiveResponse(req, response, fds, send_fds); } else { return rs; } } return n.status(); } + if (!send_fds.empty()) { + absl::Status status = socket_.SendFds(send_fds, co_); + if (!status.ok()) { + socket_.Close(); + return status; + } + } } absl::StatusOr> recv_msg = @@ -1796,7 +1860,7 @@ absl::Status ClientImpl::SendRequestReceiveResponse( socket_.Close(); if (was_connected_ && !reconnecting_) { if (absl::Status rs = Reconnect(); rs.ok()) { - return SendRequestReceiveResponse(req, response, fds); + return SendRequestReceiveResponse(req, response, fds, send_fds); } else { return rs; } @@ -1817,7 +1881,9 @@ absl::Status ClientImpl::SendRequestReceiveResponse( return s; } -absl::Status ClientImpl::SendOneWayRequest(const Request &req) { +absl::Status +ClientImpl::SendOneWayRequest(const Request &req, + const std::vector &fds) { size_t msg_len = req.ByteSizeLong(); std::vector send_msg(sizeof(int32_t) + msg_len); char *sendbuf = send_msg.data() + sizeof(int32_t); @@ -1831,21 +1897,83 @@ absl::Status ClientImpl::SendOneWayRequest(const Request &req) { socket_.Close(); if (was_connected_ && !reconnecting_) { if (absl::Status rs = Reconnect(); rs.ok()) { - return SendOneWayRequest(req); + return SendOneWayRequest(req, fds); } else { return rs; } } return n.status(); } + if (!fds.empty()) { + absl::Status status = socket_.SendFds(fds, co_); + if (!status.ok()) { + socket_.Close(); + return status; + } + } return absl::OkStatus(); } absl::Status ClientImpl::RegisterClientBuffer( - const ClientBufferHandleMetadata &metadata) { + const ClientBufferHandleMetadata &metadata, + const toolbelt::FileDescriptor *fd) { Request req; - ToProto(metadata, req.mutable_register_client_buffer()->mutable_metadata()); - return SendOneWayRequest(req); + auto *register_buffer = req.mutable_register_client_buffer(); + ToProto(metadata, register_buffer->mutable_metadata()); + std::vector fds; + if (fd != nullptr && fd->Valid()) { + register_buffer->set_has_fd(true); + register_buffer->set_fd_index(0); + fds.push_back(*fd); + } + Response response; + std::vector response_fds; + if (absl::Status status = + SendRequestReceiveResponse(req, response, response_fds, fds); + !status.ok()) { + return status; + } + if (!response.register_client_buffer().error().empty()) { + return absl::InternalError(response.register_client_buffer().error()); + } + return absl::OkStatus(); +} + +absl::StatusOr> +ClientImpl::GetClientBuffers(const std::string &channel_name, + uint64_t session_id, uint32_t buffer_index) { + Request req; + auto *get = req.mutable_get_client_buffers(); + get->set_channel_name(channel_name); + get->set_session_id(session_id); + get->set_buffer_index(buffer_index); + + Response response; + std::vector fds; + if (absl::Status status = SendRequestReceiveResponse(req, response, fds); + !status.ok()) { + return status; + } + const auto &get_resp = response.get_client_buffers(); + if (!get_resp.error().empty()) { + return absl::InternalError(get_resp.error()); + } + if (get_resp.metadata_size() != get_resp.fd_indexes_size()) { + return absl::InternalError("Malformed client buffer response"); + } + std::vector result; + result.reserve(get_resp.metadata_size()); + for (int i = 0; i < get_resp.metadata_size(); ++i) { + RegisteredClientBuffer buffer{ + .metadata = FromProto(get_resp.metadata(i)), + }; + int fd_index = get_resp.fd_indexes(i); + if (fd_index >= 0 && static_cast(fd_index) < fds.size()) { + buffer.fd = std::move(fds[size_t(fd_index)]); + } + result.push_back(std::move(buffer)); + } + return result; } absl::Status diff --git a/client/client.h b/client/client.h index 23a458b..d9c81c5 100644 --- a/client/client.h +++ b/client/client.h @@ -543,10 +543,18 @@ class ClientImpl : public std::enable_shared_from_this { absl::Status CheckConnected() const; absl::Status SendRequestReceiveResponse(const Request &req, Response &response, - std::vector &fds); - absl::Status SendOneWayRequest(const Request &req); + std::vector &fds, + const std::vector + &send_fds = {}); + absl::Status + SendOneWayRequest(const Request &req, + const std::vector &fds = {}); absl::Status RegisterClientBuffer( - const ClientBufferHandleMetadata &metadata); + const ClientBufferHandleMetadata &metadata, + const toolbelt::FileDescriptor *fd = nullptr); + absl::StatusOr> + GetClientBuffers(const std::string &channel_name, uint64_t session_id, + uint32_t buffer_index); absl::Status UnregisterClientBuffer(const std::string &channel_name, uint64_t session_id, uint32_t buffer_index); diff --git a/client/client_channel.cc b/client/client_channel.cc index ce0e4f5..ff70418 100644 --- a/client/client_channel.cc +++ b/client/client_channel.cc @@ -12,6 +12,12 @@ #include #include #include +#if defined(__ANDROID__) +#include +#ifndef MFD_CLOEXEC +#define MFD_CLOEXEC 0x0001U +#endif +#endif #include #include #include @@ -37,7 +43,7 @@ ReadSplitBufferMetadataFileWithRetry(const std::string &shadow_file) { } ClientBufferHandleMetadata ClientBufferFromSplitMetadata( - const SplitBufferMetadata &metadata, std::string allocator) { + const SplitBufferMetadata &metadata, ClientBufferAllocatorKind allocator) { return {.channel_name = metadata.channel_name, .session_id = metadata.session_id, .buffer_index = metadata.buffer_index, @@ -48,7 +54,21 @@ ClientBufferHandleMetadata ClientBufferFromSplitMetadata( .handle = metadata.handle, .shadow_file = metadata.shadow_file, .object_name = metadata.object_name, - .allocator = std::move(allocator)}; + .allocator = allocator}; +} + +[[maybe_unused]] SplitBufferMetadata SplitMetadataFromClientBuffer( + const ClientBufferHandleMetadata &metadata) { + return {.channel_name = metadata.channel_name, + .session_id = metadata.session_id, + .buffer_index = metadata.buffer_index, + .slot_id = metadata.slot_id, + .is_prefix = metadata.is_prefix, + .full_size = metadata.full_size, + .allocation_size = metadata.allocation_size, + .handle = metadata.handle, + .shadow_file = metadata.shadow_file, + .object_name = metadata.object_name}; } } // namespace @@ -276,7 +296,9 @@ absl::Status ClientChannel::AttachShmBuffers(int num_buffers) { } else { addr = nullptr; } - buffers_.emplace_back(std::make_unique(*size, slot_size, *addr)); + auto buffer_set = std::make_unique(*size, slot_size, *addr); + buffer_set->fd = std::move(*shm_fd); + buffers_.push_back(std::move(buffer_set)); } return absl::OkStatus(); } @@ -386,34 +408,69 @@ ClientChannel::CreateBuffer(int buffer_index, size_t size) { } #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(); +static absl::StatusOr +CreateAnonymousSharedMemory(const std::string &name, size_t size) { +#ifdef __NR_memfd_create + int fd = static_cast(syscall( + __NR_memfd_create, name.c_str(), static_cast(MFD_CLOEXEC))); + if (fd == -1) { + return absl::InternalError(absl::StrFormat( + "Failed to create anonymous shared memory %s: %s", name, + strerror(errno))); } - if (!shm_fd->Valid()) { - return *shm_fd; + toolbelt::FileDescriptor shm_fd(fd); + if (GetSyscallShim().ftruncate_fn(shm_fd.Fd(), off_t(size)) == -1) { + return absl::InternalError(absl::StrFormat( + "Failed to size anonymous shared memory %s: %s", name, + strerror(errno))); } + return shm_fd; +#else + return absl::UnimplementedError("memfd_create is not available"); +#endif +} - 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))); - } +absl::StatusOr +ClientChannel::CreateAndroidBuffer(const std::string &filename, size_t size) { + return CreateAnonymousSharedMemory(filename, size); +} - 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))); +absl::StatusOr +ClientChannel::GetRegisteredClientBuffer(uint32_t buffer_index, bool is_prefix, + uint32_t slot_id) { + if (!client_buffer_lookup_callback_) { + return absl::InternalError("No client buffer lookup callback registered"); } - - return *shm_fd; + absl::Status status; + // The CCB/BCB can make a buffer generation visible before the server has + // returned the registered Android memfd for that prefix/slot. Poll briefly + // for the registration to catch up before treating it as missing. + for (int attempt = 0; attempt < 100; attempt++) { + absl::StatusOr> buffers = + client_buffer_lookup_callback_(ResolvedName(), session_id_, + buffer_index); + if (!buffers.ok()) { + return buffers.status(); + } + for (RegisteredClientBuffer &buffer : *buffers) { + if (buffer.metadata.is_prefix == is_prefix && + buffer.metadata.slot_id == slot_id) { + if (!buffer.fd.Valid() && + buffer.metadata.allocator != + ClientBufferAllocatorKind::kSplitCallback) { + return absl::InternalError(absl::StrFormat( + "Registered client buffer %s/%u/%u missing FD", ResolvedName(), + buffer_index, slot_id)); + } + return std::move(buffer); + } + } + status = absl::NotFoundError(absl::StrFormat( + "No registered client buffer for %s buffer %u slot %u prefix %d", + ResolvedName(), buffer_index, slot_id, is_prefix)); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + return status; } #endif @@ -534,13 +591,21 @@ ClientChannel::CreateSplitBufferSet(size_t buffer_index, size_t full_size, .shadow_file = prefix_name, .object_name = SplitBufferObjectName(prefix_name), }; +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + auto prefix_fd = + CreateAnonymousSharedMemory(prefix_metadata.object_name, + prefix_metadata.allocation_size); +#else auto prefix_fd = CreateSplitSharedMemoryBuffer(prefix_metadata); +#endif if (!prefix_fd.ok()) { return prefix_fd.status(); } +#if SUBSPACE_SHMEM_MODE != SUBSPACE_SHMEM_MODE_ANDROID if (!prefix_fd->Valid()) { return OpenSplitBufferSet(buffer_index, full_size, slot_size); } +#endif auto prefix_addr = MapBuffer(*prefix_fd, prefix_metadata.allocation_size, BufferMapMode::kReadWrite); @@ -548,13 +613,17 @@ ClientChannel::CreateSplitBufferSet(size_t buffer_index, size_t full_size, return prefix_addr.status(); } prefix_metadata.handle = static_cast(prefix_fd->Fd()); +#if SUBSPACE_SHMEM_MODE != SUBSPACE_SHMEM_MODE_ANDROID if (absl::Status status = WriteSplitBufferMetadataFile(prefix_metadata); !status.ok()) { return status; } +#endif if (client_buffer_registration_callback_) { if (absl::Status status = client_buffer_registration_callback_( - ClientBufferFromSplitMetadata(prefix_metadata, "split_shm")); + ClientBufferFromSplitMetadata( + prefix_metadata, ClientBufferAllocatorKind::kSplitShm), + &*prefix_fd); !status.ok()) { (void)DestroySplitSharedMemoryBuffer(prefix_metadata); return status; @@ -608,15 +677,23 @@ ClientChannel::CreateSplitBufferSet(size_t buffer_index, size_t full_size, metadata.handle = slot_handle; metadata.allocation_size = slot_mapped_size; } else { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + auto created_fd = + CreateAnonymousSharedMemory(metadata.object_name, + metadata.allocation_size); +#else auto created_fd = CreateSplitSharedMemoryBuffer(metadata); +#endif if (!created_fd.ok()) { return created_fd.status(); } +#if SUBSPACE_SHMEM_MODE != SUBSPACE_SHMEM_MODE_ANDROID if (!created_fd->Valid()) { return absl::InternalError(absl::StrFormat( "Split buffer slot already exists for channel %s slot %d", ResolvedName(), slot)); } +#endif auto addr = MapBuffer(*created_fd, payload_size, MapMode()); if (!addr.ok()) { return addr.status(); @@ -626,15 +703,20 @@ ClientChannel::CreateSplitBufferSet(size_t buffer_index, size_t full_size, slot_fd.emplace(std::move(*created_fd)); metadata.handle = slot_handle; } +#if SUBSPACE_SHMEM_MODE != SUBSPACE_SHMEM_MODE_ANDROID if (absl::Status status = WriteSplitBufferMetadataFile(metadata); !status.ok()) { return status; } +#endif if (client_buffer_registration_callback_) { if (absl::Status status = client_buffer_registration_callback_( ClientBufferFromSplitMetadata( - metadata, buffer->uses_split_callbacks ? "split_callback" - : "split_shm")); + metadata, + buffer->uses_split_callbacks + ? ClientBufferAllocatorKind::kSplitCallback + : ClientBufferAllocatorKind::kSplitShm), + slot_fd.has_value() ? &*slot_fd : nullptr); !status.ok()) { return status; } @@ -660,6 +742,26 @@ ClientChannel::OpenSplitBufferSet(size_t buffer_index, size_t full_size, std::string metadata_base = base.empty() || base[0] == '/' ? base : "/tmp/" + base; std::string prefix_name = metadata_base + "_prefix"; +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + absl::StatusOr prefix_registered = + GetRegisteredClientBuffer(static_cast(buffer_index), + /*is_prefix=*/true, /*slot_id=*/0); + if (!prefix_registered.ok()) { + return prefix_registered.status(); + } + auto prefix_addr = + MapBuffer(prefix_registered->fd, prefix_registered->metadata.allocation_size, + BufferMapMode::kReadWrite); + if (!prefix_addr.ok()) { + return prefix_addr.status(); + } + buffer->split_prefix_fd = std::move(prefix_registered->fd); + buffer->split_prefix_buffer = *prefix_addr; + buffer->split_prefix_buffer_size = + prefix_registered->metadata.allocation_size; + buffer->split_prefix_metadata = + SplitMetadataFromClientBuffer(prefix_registered->metadata); +#else auto prefix_metadata = ReadSplitBufferMetadataFileWithRetry(prefix_name); if (!prefix_metadata.ok()) { return prefix_metadata.status(); @@ -678,6 +780,7 @@ ClientChannel::OpenSplitBufferSet(size_t buffer_index, size_t full_size, buffer->split_prefix_buffer = *prefix_addr; buffer->split_prefix_buffer_size = prefix_metadata->allocation_size; buffer->split_prefix_metadata = std::move(*prefix_metadata); +#endif buffer->split_slot_buffers.resize(NumSlots(), nullptr); buffer->split_slot_sizes.resize(NumSlots(), payload_size); buffer->split_handles.resize(NumSlots(), 0); @@ -686,17 +789,30 @@ ClientChannel::OpenSplitBufferSet(size_t buffer_index, size_t full_size, buffer->split_fds.reserve(NumSlots()); buffer->uses_split_callbacks = static_cast(SplitBuffersCallbacks().map); for (int slot = 0; slot < NumSlots(); slot++) { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + absl::StatusOr registered = + GetRegisteredClientBuffer(static_cast(buffer_index), + /*is_prefix=*/false, + static_cast(slot)); + if (!registered.ok()) { + return registered.status(); + } + SplitBufferMetadata metadata = + SplitMetadataFromClientBuffer(registered->metadata); +#else std::string shadow_file = absl::StrFormat("%s_slot_%d", metadata_base, slot); - auto metadata = ReadSplitBufferMetadataFileWithRetry(shadow_file); - if (!metadata.ok()) { - return metadata.status(); + auto metadata_or = ReadSplitBufferMetadataFileWithRetry(shadow_file); + if (!metadata_or.ok()) { + return metadata_or.status(); } + SplitBufferMetadata metadata = std::move(*metadata_or); +#endif char *slot_addr = nullptr; - uintptr_t slot_handle = metadata->handle; + uintptr_t slot_handle = metadata.handle; uint64_t slot_mapped_size = payload_size; void *slot_private_data = nullptr; if (SplitBuffersCallbacks().map) { - auto mapping = SplitBuffersCallbacks().map(*metadata); + auto mapping = SplitBuffersCallbacks().map(metadata); if (!mapping.ok()) { return mapping.status(); } @@ -705,29 +821,34 @@ ClientChannel::OpenSplitBufferSet(size_t buffer_index, size_t full_size, "Split buffer map callback returned an empty mapping"); } slot_addr = static_cast(mapping->address); - slot_handle = mapping->handle == 0 ? metadata->handle : mapping->handle; + slot_handle = mapping->handle == 0 ? metadata.handle : mapping->handle; slot_mapped_size = mapping->size == 0 ? payload_size : static_cast(mapping->size); slot_private_data = mapping->private_data; } else { - auto slot_fd = OpenSplitSharedMemoryBuffer(*metadata, O_RDWR); - if (!slot_fd.ok()) { - return slot_fd.status(); +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + toolbelt::FileDescriptor slot_fd = std::move(registered->fd); +#else + auto slot_fd_or = OpenSplitSharedMemoryBuffer(metadata, O_RDWR); + if (!slot_fd_or.ok()) { + return slot_fd_or.status(); } - auto addr = MapBuffer(*slot_fd, payload_size, MapMode()); + toolbelt::FileDescriptor slot_fd = std::move(*slot_fd_or); +#endif + auto addr = MapBuffer(slot_fd, payload_size, MapMode()); if (!addr.ok()) { return addr.status(); } slot_addr = *addr; - slot_handle = static_cast(slot_fd->Fd()); - buffer->split_fds.push_back(std::move(*slot_fd)); + slot_handle = static_cast(slot_fd.Fd()); + buffer->split_fds.push_back(std::move(slot_fd)); } buffer->split_handles[slot] = slot_handle; buffer->split_slot_buffers[slot] = slot_addr; buffer->split_slot_sizes[slot] = slot_mapped_size; buffer->split_private_data[slot] = slot_private_data; - buffer->split_metadata.push_back(std::move(*metadata)); + buffer->split_metadata.push_back(std::move(metadata)); } return buffer; } @@ -736,7 +857,13 @@ absl::StatusOr ClientChannel::OpenBuffer(int buffer_index) { std::string filename = BufferSharedMemoryName(buffer_index); #if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID - return OpenSharedMemoryFile(filename, O_RDWR); + absl::StatusOr buffer = + GetRegisteredClientBuffer(static_cast(buffer_index), + /*is_prefix=*/false, /*slot_id=*/0); + if (!buffer.ok()) { + return buffer.status(); + } + return std::move(buffer->fd); #elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX // Open the shared memory file. return OpenSharedMemoryFile(filename, O_RDWR); diff --git a/client/client_channel.h b/client/client_channel.h index f92b99f..145b423 100644 --- a/client/client_channel.h +++ b/client/client_channel.h @@ -62,6 +62,7 @@ struct BufferSet { uint64_t full_size = 0; uint64_t slot_size = 0; char *buffer = nullptr; + toolbelt::FileDescriptor fd; char *split_prefix_buffer = nullptr; uint64_t split_prefix_buffer_size = 0; std::vector split_slot_buffers; @@ -310,10 +311,16 @@ class ClientChannel : public Channel { } void SetClientBufferRegistrationCallback( - std::function + std::function callback) { client_buffer_registration_callback_ = std::move(callback); } + void SetClientBufferLookupCallback( + std::function>( + const std::string &, uint64_t, uint32_t)> callback) { + client_buffer_lookup_callback_ = std::move(callback); + } void SetClientBufferUnregistrationCallback( std::function callback) { @@ -360,6 +367,9 @@ class ClientChannel : public Channel { #if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID absl::StatusOr CreateAndroidBuffer(const std::string &filename, size_t size); + absl::StatusOr + GetRegisteredClientBuffer(uint32_t buffer_index, bool is_prefix, + uint32_t slot_id); #elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_LINUX absl::StatusOr CreateLinuxBuffer(const std::string &filename, size_t size); @@ -382,8 +392,12 @@ class ClientChannel : public Channel { MessageSlot *slot_ = nullptr; // Current slot. int vchan_id_ = -1; // Virtual channel ID. uint64_t session_id_; - std::function + std::function client_buffer_registration_callback_ = nullptr; + std::function>( + const std::string &, uint64_t, uint32_t)> + client_buffer_lookup_callback_ = nullptr; std::function client_buffer_unregistration_callback_ = nullptr; std::vector> buffers_ = {}; diff --git a/client/client_test.cc b/client/client_test.cc index 185341d..11a07e2 100644 --- a/client/client_test.cc +++ b/client/client_test.cc @@ -5300,7 +5300,11 @@ class PluginTest : public ::testing::Test { public: static void SetUpTestSuite() { printf("Starting Subspace server with NOP 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/client/publisher.cc b/client/publisher.cc index b925ec8..56aa8e6 100644 --- a/client/publisher.cc +++ b/client/publisher.cc @@ -5,6 +5,7 @@ #include "client/publisher.h" #include "client/checksum.h" #include "client_channel.h" +#include "common/client_buffer.h" #include "toolbelt/clock.h" #include #include @@ -38,7 +39,14 @@ absl::Status PublisherImpl::CreateOrAttachBuffers(uint64_t final_slot_size) { current_slot_size = final_slot_size; continue; } +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + absl::StatusOr shm_fd = + buffer_index < size_t(num_buffers) + ? OpenBuffer(buffer_index) + : CreateBuffer(buffer_index, final_buffer_size); +#else auto shm_fd = CreateBuffer(buffer_index, final_buffer_size); +#endif if (!shm_fd.ok()) { return shm_fd.status(); } @@ -63,8 +71,10 @@ absl::Status PublisherImpl::CreateOrAttachBuffers(uint64_t final_slot_size) { } else { addr = nullptr; } - buffers_.emplace_back( - std::make_unique(*size, current_slot_size, *addr)); + auto buffer_set = + std::make_unique(*size, current_slot_size, *addr); + buffer_set->fd = std::move(*shm_fd); + buffers_.push_back(std::move(buffer_set)); bcb_->sizes[buffers_.size()].store(final_buffer_size, std::memory_order_relaxed); } else { @@ -76,8 +86,10 @@ absl::Status PublisherImpl::CreateOrAttachBuffers(uint64_t final_slot_size) { if (!addr.ok()) { return addr.status(); } - buffers_.emplace_back(std::make_unique( - final_buffer_size, final_slot_size, *addr)); + auto buffer_set = std::make_unique( + final_buffer_size, final_slot_size, *addr); + buffer_set->fd = std::move(*shm_fd); + buffers_.push_back(std::move(buffer_set)); current_slot_size = final_slot_size; } } @@ -85,12 +97,47 @@ absl::Status PublisherImpl::CreateOrAttachBuffers(uint64_t final_slot_size) { // Update the atomic numBuffers in the CCB. If this fails it means // something else got there before us and we just go back and remap any new // buffers. +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + int old_num_buffers = num_buffers; +#endif if (ccb_->num_buffers.compare_exchange_strong(num_buffers, new_num_buffers, std::memory_order_release, std::memory_order_relaxed)) { +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + if (!UseSplitBuffers() && client_buffer_registration_callback_) { + for (int i = old_num_buffers; i < new_num_buffers; i++) { + BufferSet &buffer = *buffers_[i]; + ClientBufferHandleMetadata metadata = { + .channel_name = ResolvedName(), + .session_id = session_id_, + .buffer_index = static_cast(i), + .slot_id = 0, + .is_prefix = false, + .full_size = buffer.full_size, + .allocation_size = buffer.full_size, + .handle = static_cast(buffer.fd.Fd()), + .allocator = ClientBufferAllocatorKind::kAndroidMemfd, + }; + if (absl::Status status = + client_buffer_registration_callback_(metadata, &buffer.fd); + !status.ok()) { + return status; + } + } + } +#endif // We successfully updated the number of buffers in the CCB. break; } +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID + if (!UseSplitBuffers()) { + for (size_t i = 0; i < buffers_.size(); i++) { + UnmapBufferSet(i, *buffers_[i], /*destroy_owned_buffers=*/false); + } + buffers_.clear(); + current_slot_size = 0; + } +#endif // Another thread has updated the number of buffers in the CCB. We need to // retry. } diff --git a/client/syscall_failure_test.cc b/client/syscall_failure_test.cc index 6f16214..befcbb9 100644 --- a/client/syscall_failure_test.cc +++ b/client/syscall_failure_test.cc @@ -86,6 +86,7 @@ TEST_F(SyscallFailureTest, MmapFailOnBcb) { // shm_open failures during CreateBuffer // --------------------------------------------------------------------------- +#if !defined(__ANDROID__) TEST_F(SyscallFailureTest, ShmOpenFail) { auto client = EVAL_AND_ASSERT_OK( subspace::Client::Create(Socket(), "shm_open_test")); @@ -101,6 +102,7 @@ TEST_F(SyscallFailureTest, ShmOpenFail) { EXPECT_THAT(pub.status().message(), ::testing::HasSubstr("Failed to open shared memory")); } +#endif // --------------------------------------------------------------------------- // ftruncate failure after successful shm_open (should shm_unlink on cleanup) @@ -123,13 +125,15 @@ TEST_F(SyscallFailureTest, FtruncateFailAfterShmOpen) { pub.status().message(), ::testing::AnyOf( ::testing::HasSubstr("Failed to set length of shared memory"), - ::testing::HasSubstr("Failed to truncate shadow file"))); + ::testing::HasSubstr("Failed to truncate shadow file"), + ::testing::HasSubstr("Failed to size anonymous shared memory"))); } // --------------------------------------------------------------------------- // chmod failure during CreateBuffer // --------------------------------------------------------------------------- +#if !defined(__ANDROID__) TEST_F(SyscallFailureTest, ChmodFail) { auto client = EVAL_AND_ASSERT_OK( subspace::Client::Create(Socket(), "chmod_test")); @@ -145,6 +149,7 @@ TEST_F(SyscallFailureTest, ChmodFail) { EXPECT_THAT(pub.status().message(), ::testing::HasSubstr("Failed to change permissions")); } +#endif // --------------------------------------------------------------------------- // poll failures in WaitForSubscriber @@ -244,12 +249,16 @@ TEST_F(SyscallFailureTest, ShimCallCounting) { // Verify that mmap was called at least 3 times (SCB, CCB, BCB). EXPECT_GE(shim.mmap_call_count, 3); +#if !defined(__ANDROID__) // Verify that shm_open was called at least once (for buffer creation). EXPECT_GE(shim.shm_open_call_count, 1); +#endif // Verify that ftruncate was called at least once. EXPECT_GE(shim.ftruncate_call_count, 1); +#if !defined(__ANDROID__) // Verify that chmod was called at least once. EXPECT_GE(shim.chmod_call_count, 1); +#endif } // --------------------------------------------------------------------------- diff --git a/client/test_fixture.h b/client/test_fixture.h index e188100..296107e 100644 --- a/client/test_fixture.h +++ b/client/test_fixture.h @@ -42,7 +42,11 @@ class SubspaceTestBase : public ::testing::Test { public: static void SetUpTestSuite() { printf("Starting Subspace server\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 index fab36e5..7f17941 100644 --- a/common/Android.bp +++ b/common/Android.bp @@ -12,24 +12,15 @@ cc_library_static { "syscall_shim.cc", ], export_include_dirs: ["."], - local_include_dirs: [".."], + include_dirs: ["external/subspace"], static_libs: [ "libsubspace_proto", "libcoroutines", "libcpp_toolbelt", + "libabsl", ], shared_libs: [ - "libprotobuf-cpp-lite", + "libprotobuf-cpp-full", "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/CMakeLists.txt b/common/CMakeLists.txt index 611ff26..0861d05 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -20,6 +20,7 @@ add_library(subspace_common STATIC target_link_libraries(subspace_common PUBLIC absl::base absl::flags + absl::flat_hash_map absl::flat_hash_set absl::strings absl::str_format diff --git a/common/channel.cc b/common/channel.cc index 2c7343f..117051c 100644 --- a/common/channel.cc +++ b/common/channel.cc @@ -23,14 +23,6 @@ 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 @@ -127,10 +119,8 @@ std::string Channel::BufferSharedMemoryName(uint64_t session_id, absl::StrReplaceAll(ResolvedName(), {{"/", "."}}); #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); + return absl::StrFormat("subspace_%d_%s_%d", 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 diff --git a/common/channel.h b/common/channel.h index d626c74..1d94dfe 100644 --- a/common/channel.h +++ b/common/channel.h @@ -29,7 +29,7 @@ namespace subspace { // Change this if you want to use a different shared memory mode. #if defined(__ANDROID__) -// Android does not have /dev/shm; use regular files on a tmpfs-backed dir. +// Android does not have /dev/shm; use anonymous fd-backed shared memory. #define SUBSPACE_SHMEM_MODE SUBSPACE_SHMEM_MODE_ANDROID #elif defined(__linux__) // On Linux we can use /dev/shm directly for shared memory. @@ -40,12 +40,6 @@ 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/client_buffer.h b/common/client_buffer.h index e434b7c..777425c 100644 --- a/common/client_buffer.h +++ b/common/client_buffer.h @@ -4,13 +4,38 @@ #pragma once -#include "google/protobuf/any.pb.h" +#include "toolbelt/fd.h" #include #include namespace subspace { +enum class ClientBufferAllocatorKind { + kUnspecified = 0, + kAndroidMemfd = 1, + kSplitShm = 2, + kSplitCallback = 3, + kSplitBufferFreeTest = 4, +}; + +inline const char * +ClientBufferAllocatorName(ClientBufferAllocatorKind allocator) { + switch (allocator) { + case ClientBufferAllocatorKind::kAndroidMemfd: + return "android_memfd"; + case ClientBufferAllocatorKind::kSplitShm: + return "split_shm"; + case ClientBufferAllocatorKind::kSplitCallback: + return "split_callback"; + case ClientBufferAllocatorKind::kSplitBufferFreeTest: + return "split_buffer_free_test"; + case ClientBufferAllocatorKind::kUnspecified: + default: + return "unspecified"; + } +} + // Metadata for memory allocated by a client but cleaned up by the server if the // client cannot release it itself. The handle is allocator-defined; plugins // decide whether they understand it. @@ -25,11 +50,12 @@ struct ClientBufferHandleMetadata { uintptr_t handle = 0; std::string shadow_file; std::string object_name; - std::string allocator; - std::string pool_id; - bool cache_enabled = false; - uint32_t alignment = 0; - google::protobuf::Any allocator_metadata; + ClientBufferAllocatorKind allocator = ClientBufferAllocatorKind::kUnspecified; +}; + +struct RegisteredClientBuffer { + ClientBufferHandleMetadata metadata; + toolbelt::FileDescriptor fd; }; } // namespace subspace diff --git a/common/split_buffer.cc b/common/split_buffer.cc index 5011cb7..ea63329 100644 --- a/common/split_buffer.cc +++ b/common/split_buffer.cc @@ -15,6 +15,12 @@ #include #include #include +#if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_ANDROID +#include +#ifndef MFD_CLOEXEC +#define MFD_CLOEXEC 0x0001U +#endif +#endif #include namespace subspace { @@ -170,14 +176,37 @@ std::string SplitBufferObjectName(const std::string &shadow_file) { absl::StatusOr CreateSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata) { + uint64_t allocation_size = + metadata.allocation_size != 0 ? metadata.allocation_size + : PageAlignedSize(metadata.full_size); #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); + // Android has no named shared memory, so back the buffer with an anonymous + // memfd. Ownership of the descriptor is returned to the caller; subscribers + // receive their own copy of it from the server rather than reopening by name. +#ifdef __NR_memfd_create + int fd = static_cast( + syscall(__NR_memfd_create, metadata.object_name.c_str(), + static_cast(MFD_CLOEXEC))); + if (fd == -1) { + return absl::InternalError(absl::StrFormat( + "Failed to create split buffer object %s: %s", metadata.object_name, + strerror(errno))); + } +#else + return absl::UnimplementedError("memfd_create is not available"); +#endif + toolbelt::FileDescriptor shm_fd(fd); + if (GetSyscallShim().ftruncate_fn( + shm_fd.Fd(), static_cast(PageAlignedSize(allocation_size))) == + -1) { + return absl::InternalError(absl::StrFormat( + "Failed to size split buffer object %s: %s", metadata.object_name, + strerror(errno))); + } + return shm_fd; #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(); @@ -188,51 +217,52 @@ CreateSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata) { } toolbelt::FileDescriptor shm_fd(fd); - uint64_t allocation_size = - metadata.allocation_size != 0 ? metadata.allocation_size - : 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))); } return shm_fd; +#endif } 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); + (void)flags; + // Anonymous memfds cannot be reopened by name; the client obtains its + // descriptors directly (from creation or via the server) instead. + return absl::UnimplementedError(absl::StrFormat( + "Cannot reopen anonymous split buffer object %s by name", + metadata.object_name)); #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, strerror(errno))); } return toolbelt::FileDescriptor(fd); +#endif } 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) { + // Android buffers are anonymous memfds with no backing name and no shadow + // metadata file (subscribers receive descriptors from the server, not by + // name). The memory is released when the owning descriptor and all mappings + // are dropped, so there is nothing to remove. + (void)metadata; + return absl::OkStatus(); #else + absl::Status status = absl::OkStatus(); 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))); @@ -244,6 +274,7 @@ absl::Status DestroySplitSharedMemoryBuffer( strerror(errno))); } return status; +#endif } } // namespace subspace diff --git a/common/split_buffer.h b/common/split_buffer.h index 283a78e..a547f66 100644 --- a/common/split_buffer.h +++ b/common/split_buffer.h @@ -63,6 +63,11 @@ ReadSplitBufferMetadataFile(const std::string &shadow_file); std::string SplitBufferObjectName(const std::string &shadow_file); +// On Android these objects are anonymous memfds: CreateSplitSharedMemoryBuffer +// returns a caller-owned descriptor, and OpenSplitSharedMemoryBuffer is +// unsupported because an anonymous memfd cannot be reopened by name (the client +// shares its descriptors with subscribers via the server instead). Other +// platforms use named POSIX/Linux shared memory and support reopen by name. absl::StatusOr CreateSplitSharedMemoryBuffer(const SplitBufferMetadata &metadata); absl::StatusOr diff --git a/common/split_buffer_test.cc b/common/split_buffer_test.cc index 8d1e6c3..c0df263 100644 --- a/common/split_buffer_test.cc +++ b/common/split_buffer_test.cc @@ -48,7 +48,7 @@ SplitBufferMetadata TestMetadata(const std::string &suffix) { TEST(SplitBufferTest, WritesAndReadsMetadata) { SplitBufferMetadata metadata = TestMetadata("metadata"); - (void)DestroySplitSharedMemoryBuffer(metadata); + (void)unlink(metadata.shadow_file.c_str()); ASSERT_TRUE(WriteSplitBufferMetadataFile(metadata).ok()); auto read_metadata = ReadSplitBufferMetadataFile(metadata.shadow_file); @@ -65,7 +65,7 @@ TEST(SplitBufferTest, WritesAndReadsMetadata) { EXPECT_EQ(read_metadata->shadow_file, metadata.shadow_file); EXPECT_EQ(read_metadata->object_name, metadata.object_name); - (void)DestroySplitSharedMemoryBuffer(metadata); + (void)unlink(metadata.shadow_file.c_str()); } TEST(SplitBufferTest, CreatesOpensAndDestroysSharedMemoryObject) { @@ -76,6 +76,16 @@ TEST(SplitBufferTest, CreatesOpensAndDestroysSharedMemoryObject) { ASSERT_TRUE(created.ok()) << created.status(); ASSERT_TRUE(created->Valid()); + struct stat created_sb; + ASSERT_EQ(fstat(created->Fd(), &created_sb), 0); + EXPECT_GE(static_cast(created_sb.st_size), metadata.allocation_size); + +#if defined(__ANDROID__) + // Anonymous memfds cannot be reopened by name; the caller owns the descriptor + // returned by CreateSplitSharedMemoryBuffer instead. There is no shadow file + // on Android. + EXPECT_FALSE(OpenSplitSharedMemoryBuffer(metadata, O_RDWR).ok()); +#else ASSERT_TRUE(WriteSplitBufferMetadataFile(metadata).ok()); auto opened = OpenSplitSharedMemoryBuffer(metadata, O_RDWR); ASSERT_TRUE(opened.ok()) << opened.status(); @@ -84,9 +94,12 @@ TEST(SplitBufferTest, CreatesOpensAndDestroysSharedMemoryObject) { struct stat sb; ASSERT_EQ(fstat(opened->Fd(), &sb), 0); EXPECT_GE(static_cast(sb.st_size), metadata.allocation_size); +#endif ASSERT_TRUE(DestroySplitSharedMemoryBuffer(metadata).ok()); +#if !defined(__ANDROID__) EXPECT_FALSE(OpenSplitSharedMemoryBuffer(metadata, O_RDWR).ok()); +#endif } } // namespace diff --git a/docs/android.md b/docs/android.md index a62f7da..c0688f7 100644 --- a/docs/android.md +++ b/docs/android.md @@ -47,13 +47,26 @@ emulator -avd subspace_test -no-window -no-audio -gpu swiftshader_indirect & adb wait-for-device ``` -## Cross-Compiling +## Building With Bazel -Build the server and tests for Android ARM64: +Bazel is the simplest way to cross-compile Subspace Android artifacts from this +repository because it fetches its own C++ dependencies and uses the NDK +toolchain configured in `.bazelrc`. + +Build the server, native tests, JNI library, and Java client test for Android +ARM64: ```bash -bazelisk build //server:subspace_server //client:client_test \ - --config=android_arm64 +bazelisk build \ + //server:subspace_server \ + //client:client_test \ + //c_client:client_test \ + //plugins:nop_plugin.so \ + //plugins:split_buffer_free_test_plugin.so \ + //android/jni:libsubspace_jni.so \ + //android/java:subspace-java \ + //android/java:subspace-java-test \ + --config=android_arm64 ``` The `android_arm64` config in `.bazelrc` sets: @@ -62,6 +75,8 @@ The `android_arm64` config in `.bazelrc` sets: - `--linkopt=-lc++_static --linkopt=-lc++abi` (NDK C++ stdlib) - `--action_env=ANDROID_NDK_HOME` +For an x86_64 emulator or CI runner, use `--config=android_x86_64` instead. + ## Device Setup ### Enable root access @@ -72,26 +87,13 @@ The emulator with `google_apis` images supports `adb root`: 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 +## Deploying Bazel Binaries Bazel produces shared libraries as symlinks in `bazel-bin/_solib_arm64-v8a/`. You must dereference them before pushing to the device: @@ -114,7 +116,7 @@ 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 +## Running Bazel-built Tests ### Start the server @@ -122,8 +124,8 @@ adb push bazel-bin/plugins/split_buffer_free_test_plugin.so /data/local/tmp/plug 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. +The server uses the default socket `/data/local/tmp/subspace` on Android. Shared +memory is fd-backed and does not require a device-visible directory. ### Run tests @@ -148,21 +150,20 @@ adb shell "cd /data/local/tmp && LD_LIBRARY_PATH=/data/local/tmp/android_libs \ 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) +- Creates anonymous `memfd_create()` regions for the SCB, CCB, BCB, and + client-owned message buffers. +- Sizes them with `ftruncate()` and maps them with `mmap()`. - 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. + (`SCM_RIGHTS`). +- Keeps client-side buffer allocation and resize by registering publisher-owned + buffer FDs with the server, which brokers them to subscribers. ### 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. +Built-in split buffers also use anonymous FDs. The publisher registers the +prefix and slot FDs with the server; subscribers fetch those descriptors when +attaching to a new buffer generation. Custom split-buffer callbacks continue to +use the callback-provided handles. ### Linker Namespaces @@ -170,31 +171,43 @@ 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 +## Building With CMake -Subspace can be cross-compiled for Android using CMake with the NDK toolchain: +Subspace can also be cross-compiled for Android using CMake with the NDK +toolchain. CMake fetches the same third-party dependencies with +`FetchContent`, but protobuf code generation requires a host-native `protoc` +that matches the protobuf version used by the Android build. ```bash export ANDROID_NDK_HOME=/path/to/ndk +# Build a host protoc matching Subspace's protobuf dependency. +cmake -S . -B build/host-protoc -DCMAKE_BUILD_TYPE=Release +cmake --build build/host-protoc --target protoc --parallel + 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 + -DCMAKE_BUILD_TYPE=Release \ + -DPROTOC_EXECUTABLE="$PWD/build/host-protoc/_deps/protobuf-build/protoc" 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: +Use `-DANDROID_ABI=x86_64` for an x86_64 emulator. The Android CMake build +produces the native test binaries plus the Java/JNI artifacts: -```bash -cmake -S . -B build/native && cmake --build build/native --target subspace_proto -cp build/native/proto/subspace.pb.{cc,h} proto/ -``` +- `build/android/server/subspace_server` +- `build/android/client/client_test` +- `build/android/c_client/c_client_test` +- `build/android/android/libsubspace_jni.so` +- `build/android/android/subspace-java.jar` +- `build/android/android/subspace-java-test.jar` + +The CI helper script `.github/scripts/cmake-android-test.sh` shows the expected +deployment layout and how to run the CMake-built tests on an emulator. ## AOSP / Soong (Blueprint) Build @@ -202,6 +215,10 @@ 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. +Soong builds require a full AOSP checkout. GitHub-hosted runners do not provide +one by default; use a local AOSP tree or a self-hosted CI runner with AOSP +already synced. + ### Directory Layout Place the subspace source tree in your AOSP checkout (e.g., @@ -216,6 +233,7 @@ Place the subspace source tree in your AOSP checkout (e.g., | `libsubspace_proto` | static lib | Protobuf message definitions | | `libsubspace_jni` | shared lib | JNI bindings for Java clients | | `subspace-java` | java lib | Java client wrapper | +| `subspace_java_client_test` | java binary | Device-side Java integration test | ### External Dependencies @@ -225,39 +243,110 @@ 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. +Example Blueprint files for both are provided in +`external/coroutines/Android.bp.example` and +`external/cpp_toolbelt/Android.bp.example` within this repository. Copy these to +`Android.bp` in 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 +- `libprotobuf-cpp-full` — Protocol Buffers runtime. `subspace.proto` uses + `google.protobuf.Any`, which is not available from the lite 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 +- `libabsl` — Abseil runtime and headers - `jni_headers` — JNI headers (for the JNI module) ### Building +Add Subspace to a product makefile: + +```make +PRODUCT_SOONG_NAMESPACES += external/subspace +PRODUCT_PACKAGES += \ + subspace_server \ + libsubspace_client \ + libsubspace_jni \ + subspace-java \ + subspace_java_client_test +``` + +Then build from your AOSP root: + +```bash +source build/envsetup.sh +lunch -userdebug + +m external.subspace-subspace_server-soong \ + external.subspace-libsubspace_client-soong \ + external.subspace-libsubspace_jni-soong \ + external.subspace-subspace-java-soong \ + external.subspace-subspace_java_client_test-soong +``` + +After flashing or installing those artifacts on a device image, the Java +integration test can be run through its wrapper: + ```bash -# From your AOSP root: -m subspace_server libsubspace_client libsubspace_jni subspace-java +adb shell subspace_java_client_test ``` ### Integration Notes - The `subspace_defaults` module in the root `Android.bp` sets C++17 mode, - warning flags, and the `-DSUBSPACE_ANDROID` preprocessor define. + warning flags, exceptions/RTTI, 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. +## Bridging Between the Emulator and the Host + +A Subspace server inside the emulator can bridge channels to a server running +natively on the host, in both directions (publish on Android / subscribe on the +host, and vice versa). The emulator's user‑mode network is a NAT where only the +guest can initiate connections and UDP broadcast does not cross the boundary, so +two server features are used: + +- `--tcp_discovery` — run discovery over a single TCP connection that the guest + dials to the host (instead of UDP broadcast/unicast). See + [`server-architecture.md`](server-architecture.md) for details. +- `--bridge_advertise_address=127.0.0.1` — advertise a loopback endpoint for + bridge listeners, reached through `adb` port tunnels. + +The host and guest use **different** bridge ports so the `adb forward`/`reverse` +loopback listeners never collide with a server's own listener. With the host +acting as the discovery listener: + +```bash +# Tunnels: guest dials out to the host (reverse); host dials into the guest (forward). +adb reverse tcp:6502 tcp:6502 # discovery: guest -> host +adb reverse tcp:7100 tcp:7100 # bridge data: guest publisher -> host subscriber +adb forward tcp:7200 tcp:7200 # bridge data: host publisher -> guest subscriber + +# Host (discovery listener): +./subspace_server --socket=/tmp/subspace_host --tcp_discovery --disc_port=6502 \ + --bridge_ports=7100 --bridge_advertise_address=127.0.0.1 \ + --cleanup_filesystem=false + +# Guest (discovery connector), inside the emulator: +adb shell "/data/local/tmp/subspace_server --socket=/data/local/tmp/subspace \ + --tcp_discovery --peer_address=127.0.0.1 --peer_port=6502 \ + --bridge_ports=7200 --bridge_advertise_address=127.0.0.1" +``` + +Publishers must be created with `local=false` for their channels to bridge. + +The script `manual_tests/cross_host_bridge.sh` automates this end to end and +verifies both directions: + +```bash +manual_tests/cross_host_bridge.sh native # two servers on the host (loopback) +manual_tests/cross_host_bridge.sh emulator # host <-> running emulator +``` + diff --git a/docs/server-architecture.md b/docs/server-architecture.md index 62cdbd8..75824db 100644 --- a/docs/server-architecture.md +++ b/docs/server-architecture.md @@ -151,6 +151,43 @@ to an ephemeral TCP port or fails that bridge setup. Every 5 seconds, broadcasts an `Advertise` for all local channels so late-joining subscribers can discover them. +### TCP Unicast Discovery (across NAT / VMs) + +UDP discovery (broadcast or `--peer_address` unicast) assumes the two servers +can exchange datagrams directly and that each server can be reached on the +discovery port it advertises. That breaks when one server runs inside a NAT'd +environment such as an Android emulator or a VM, where only the NAT'd side can +initiate connections and the UDP "reply to the advertised port" assumption no +longer holds. + +`--tcp_discovery` replaces UDP discovery with a single TCP connection that +carries the same `Query`/`Advertise`/`Subscribe` messages (length‑delimited) +in both directions: + +- A server **with** `--peer_address` set **dials** the peer's `--disc_port`, + retrying until it connects (`DiscoveryConnectorCoroutine`). +- A server **without** a peer address **listens** on `--disc_port` for an + incoming discovery connection (`DiscoveryListenerCoroutine`). + +Because the handshake runs over one established connection, only the dialing +(NAT'd) side needs to reach the other, and there is no source‑port rewriting. +This also lets two servers run on the same host without contending for the UDP +discovery port. UDP broadcast discovery remains the default for the +zero‑configuration LAN case. + +### Advertising bridge listeners across NAT + +The bridge data channel is always TCP, with the transmitter (publisher side) +dialing the receiver (subscriber side) listener. When a server is NAT'd, its +listeners are only reachable through a forwarded loopback port (e.g. an +`adb forward`/`adb reverse` tunnel). `--bridge_advertise_address=IP` makes the +server advertise that address (typically `127.0.0.1`) for its bridge and +retirement listeners instead of the local interface address, and binds those +listeners to the any‑address so the forwarded loopback port reaches them. + +See `manual_tests/cross_host_bridge.sh` for a worked example that bridges a +channel in both directions between a host and an Android emulator. + ## Key Classes ``` diff --git a/external/coroutines/Android.bp b/external/coroutines/Android.bp.example similarity index 78% rename from external/coroutines/Android.bp rename to external/coroutines/Android.bp.example index 07bfe3c..c4863f5 100644 --- a/external/coroutines/Android.bp +++ b/external/coroutines/Android.bp.example @@ -15,13 +15,12 @@ cc_library_static { "-Wall", "-Wno-unused-parameter", ], - header_libs: [ - "libabseil-headers", - ], - whole_static_libs: [ - "libabsl_flat_hash_map", - "libabsl_flat_hash_set", + cppflags: ["-fexceptions"], + rtti: true, + static_libs: [ + "libabsl", ], stl: "c++_shared", min_sdk_version: "28", + compile_multilib: "64", } diff --git a/external/cpp_toolbelt/Android.bp b/external/cpp_toolbelt/Android.bp.example similarity index 78% rename from external/cpp_toolbelt/Android.bp rename to external/cpp_toolbelt/Android.bp.example index b80d83d..8208dcb 100644 --- a/external/cpp_toolbelt/Android.bp +++ b/external/cpp_toolbelt/Android.bp.example @@ -23,19 +23,13 @@ cc_library_static { "-Wall", "-Wno-unused-parameter", ], + cppflags: ["-fexceptions"], + rtti: true, static_libs: [ "libcoroutines", - ], - header_libs: [ - "libabseil-headers", - ], - whole_static_libs: [ - "libabsl_status", - "libabsl_statusor", - "libabsl_strings", - "libabsl_str_format_internal", - "libabsl_span", + "libabsl", ], stl: "c++_shared", min_sdk_version: "28", + compile_multilib: "64", } diff --git a/manual_tests/cross_host_bridge.sh b/manual_tests/cross_host_bridge.sh new file mode 100755 index 0000000..c03aba3 --- /dev/null +++ b/manual_tests/cross_host_bridge.sh @@ -0,0 +1,234 @@ +#!/usr/bin/env bash +# +# Manual test for cross-host Subspace bridging using TCP unicast discovery. +# +# It runs two Subspace servers and bridges a channel in *both* directions: +# - channel "g2h": published on server B, subscribed on server A +# - channel "h2g": published on server A, subscribed on server B +# +# Two modes are supported: +# +# native Both servers run on this host over loopback. This validates the +# TCP discovery + bridge code path with no emulator involved. +# +# emulator Server A ("host") runs natively; server B ("guest") runs inside a +# running Android emulator. Because the emulator sits behind a NAT +# where only the guest can dial out, we: +# * use TCP discovery with the guest dialing the host, +# * advertise 127.0.0.1 for every bridge listener, and +# * wire the loopback bridge ports through adb: +# adb reverse tcp:6502 -> host discovery listener +# adb reverse tcp:7100 -> host bridge receiver (g2h data) +# adb forward tcp:7200 -> guest bridge receiver (h2g data) +# +# Usage: +# manual_tests/cross_host_bridge.sh [native|emulator] +# +# Requirements for emulator mode: a booted emulator (`adb devices` shows one), +# the Android NDK configured for `--config=android_arm64`, and adb on PATH. + +set -uo pipefail + +MODE="${1:-native}" + +# Discovery + bridge ports. The host and guest use *different* bridge ports so +# the adb forward/reverse listeners never collide with a server's own listener. +DISC_PORT=6502 +HOST_BRIDGE_PORT=7100 # host's bridge receiver (g2h) +GUEST_BRIDGE_PORT=7200 # guest/connector bridge receiver (h2g) + +HOST_SOCKET=/tmp/subspace_bridge_host +PEER_SOCKET=/tmp/subspace_bridge_peer # native mode only +GUEST_SOCKET=/data/local/tmp/subspace # emulator mode only +ANDROID_TMP=/data/local/tmp + +LOGDIR="$(mktemp -d /tmp/subspace_bridge.XXXXXX)" +PIDS=() +SUB_TIME=3 # seconds to let subscribers + bridge establish +PUB_TIME=8 # seconds of publishing + +note() { printf '\n=== %s ===\n' "$*"; } +fail() { printf 'FAIL: %s\n' "$*" >&2; } + +cleanup() { + set +m + for p in "${PIDS[@]:-}"; do + kill "$p" 2>/dev/null + wait "$p" 2>/dev/null + done + pkill -f 'manual_tests/pub' 2>/dev/null + pkill -f 'manual_tests/sub' 2>/dev/null + pkill -f "subspace_server --socket=${HOST_SOCKET}" 2>/dev/null + pkill -f "subspace_server --socket=${PEER_SOCKET}" 2>/dev/null + if [[ "$MODE" == emulator ]]; then + adb shell "pkill subspace_server; pkill pub; pkill sub" 2>/dev/null + adb reverse --remove "tcp:${DISC_PORT}" 2>/dev/null + adb reverse --remove "tcp:${HOST_BRIDGE_PORT}" 2>/dev/null + adb forward --remove "tcp:${GUEST_BRIDGE_PORT}" 2>/dev/null + fi +} +trap cleanup EXIT + +# Count "Message" lines a subscriber printed, and PASS/FAIL accordingly. +check_dir() { + local label="$1" logfile="$2" + local n + n=$(grep -c 'Message' "$logfile" 2>/dev/null) || true + n=${n:-0} + if [[ "$n" -gt 0 ]]; then + printf 'PASS: %s delivered %s messages\n' "$label" "$n" + return 0 + fi + fail "$label delivered no messages" + printf ' --- %s ---\n' "$logfile" + sed -n '1,5p' "$logfile" 2>/dev/null | sed 's/^/ /' + return 1 +} + +run_native() { + note "Building host binaries" + bazelisk build //server:subspace_server //manual_tests:pub //manual_tests:sub \ + >"$LOGDIR/build.log" 2>&1 || { cat "$LOGDIR/build.log"; exit 1; } + + local SRV=bazel-bin/server/subspace_server + local PUB=bazel-bin/manual_tests/pub + local SUB=bazel-bin/manual_tests/sub + + rm -f "$HOST_SOCKET" "$PEER_SOCKET" + + note "Starting servers (TCP discovery over loopback)" + # Server A: discovery listener. + "$SRV" --socket="$HOST_SOCKET" --tcp_discovery --disc_port="$DISC_PORT" \ + --bridge_ports="$HOST_BRIDGE_PORT" --bridge_advertise_address=127.0.0.1 \ + --cleanup_filesystem=false --log_level=debug \ + >"$LOGDIR/serverA.log" 2>&1 & + PIDS+=($!) + # Server B: discovery connector (dials A). + "$SRV" --socket="$PEER_SOCKET" --tcp_discovery --peer_address=127.0.0.1 \ + --peer_port="$DISC_PORT" --bridge_ports="$GUEST_BRIDGE_PORT" \ + --bridge_advertise_address=127.0.0.1 \ + --cleanup_filesystem=false --log_level=debug \ + >"$LOGDIR/serverB.log" 2>&1 & + PIDS+=($!) + sleep 2 + + note "Starting subscribers" + "$SUB" --socket="$HOST_SOCKET" --channel=g2h >"$LOGDIR/sub_g2h.log" 2>&1 & + PIDS+=($!) + "$SUB" --socket="$PEER_SOCKET" --channel=h2g >"$LOGDIR/sub_h2g.log" 2>&1 & + PIDS+=($!) + sleep "$SUB_TIME" + + note "Publishing in both directions for ${PUB_TIME}s" + "$PUB" --socket="$PEER_SOCKET" --channel=g2h --local=false \ + --num_msgs=200 --frequency=25 "$LOGDIR/pub_g2h.log" 2>&1 & + PIDS+=($!) + "$PUB" --socket="$HOST_SOCKET" --channel=h2g --local=false \ + --num_msgs=200 --frequency=25 "$LOGDIR/pub_h2g.log" 2>&1 & + PIDS+=($!) + sleep "$PUB_TIME" + + local rc=0 + note "Results" + check_dir "g2h (server B -> server A)" "$LOGDIR/sub_g2h.log" || rc=1 + check_dir "h2g (server A -> server B)" "$LOGDIR/sub_h2g.log" || rc=1 + return $rc +} + +run_emulator() { + if ! adb get-state >/dev/null 2>&1; then + fail "no Android device/emulator detected (adb get-state). Start one first." + exit 1 + fi + + note "Building host and Android (arm64) binaries" + bazelisk build //server:subspace_server //manual_tests:pub //manual_tests:sub \ + >"$LOGDIR/build_host.log" 2>&1 || { cat "$LOGDIR/build_host.log"; exit 1; } + bazelisk build --config=android_arm64 \ + //server:subspace_server //manual_tests:pub //manual_tests:sub \ + >"$LOGDIR/build_android.log" 2>&1 || { cat "$LOGDIR/build_android.log"; exit 1; } + + # Resolve binary paths via cquery because the bazel-bin symlink points at + # whichever configuration was built last (here, the Android one). + local SRV PUB SUB + SRV=$(bazelisk cquery --output=files //server:subspace_server 2>/dev/null | tail -1) + PUB=$(bazelisk cquery --output=files //manual_tests:pub 2>/dev/null | tail -1) + SUB=$(bazelisk cquery --output=files //manual_tests:sub 2>/dev/null | tail -1) + local AOUT APUB AS + AOUT=$(bazelisk cquery --config=android_arm64 --output=files \ + //server:subspace_server 2>/dev/null | tail -1) + APUB=$(bazelisk cquery --config=android_arm64 --output=files \ + //manual_tests:pub 2>/dev/null | tail -1) + AS=$(bazelisk cquery --config=android_arm64 --output=files \ + //manual_tests:sub 2>/dev/null | tail -1) + + note "Pushing Android binaries to ${ANDROID_TMP}" + adb shell "pkill subspace_server; pkill pub; pkill sub" 2>/dev/null + adb push "$AOUT" "$ANDROID_TMP/subspace_server" >/dev/null + adb push "$APUB" "$ANDROID_TMP/pub" >/dev/null + adb push "$AS" "$ANDROID_TMP/sub" >/dev/null + adb shell "chmod 755 $ANDROID_TMP/subspace_server $ANDROID_TMP/pub $ANDROID_TMP/sub" + + note "Wiring adb port tunnels" + # Discovery: guest dials 127.0.0.1:DISC_PORT -> host discovery listener. + adb reverse "tcp:${DISC_PORT}" "tcp:${DISC_PORT}" + # g2h data: guest transmitter dials 127.0.0.1:HOST_BRIDGE_PORT -> host receiver. + adb reverse "tcp:${HOST_BRIDGE_PORT}" "tcp:${HOST_BRIDGE_PORT}" + # h2g data: host transmitter dials 127.0.0.1:GUEST_BRIDGE_PORT -> guest receiver. + adb forward "tcp:${GUEST_BRIDGE_PORT}" "tcp:${GUEST_BRIDGE_PORT}" + + rm -f "$HOST_SOCKET" + + note "Starting host server (discovery listener)" + "$SRV" --socket="$HOST_SOCKET" --tcp_discovery --disc_port="$DISC_PORT" \ + --bridge_ports="$HOST_BRIDGE_PORT" --bridge_advertise_address=127.0.0.1 \ + --cleanup_filesystem=false --log_level=debug \ + >"$LOGDIR/serverA.log" 2>&1 & + PIDS+=($!) + + note "Starting guest server in emulator (discovery connector)" + adb shell "rm -f $GUEST_SOCKET" 2>/dev/null + adb shell "cd $ANDROID_TMP && ./subspace_server --socket=$GUEST_SOCKET \ + --tcp_discovery --peer_address=127.0.0.1 --peer_port=$DISC_PORT \ + --bridge_ports=$GUEST_BRIDGE_PORT --bridge_advertise_address=127.0.0.1 \ + --cleanup_filesystem=false --log_level=debug" >"$LOGDIR/serverB.log" 2>&1 & + PIDS+=($!) + sleep 3 + + note "Starting subscribers" + # g2h: host subscribes. + "$SUB" --socket="$HOST_SOCKET" --channel=g2h >"$LOGDIR/sub_g2h.log" 2>&1 & + PIDS+=($!) + # h2g: guest subscribes. + adb shell "$ANDROID_TMP/sub --socket=$GUEST_SOCKET --channel=h2g" \ + >"$LOGDIR/sub_h2g.log" 2>&1 & + PIDS+=($!) + sleep "$SUB_TIME" + + note "Publishing in both directions for ${PUB_TIME}s" + # g2h: guest publishes. + adb shell "$ANDROID_TMP/pub --socket=$GUEST_SOCKET --channel=g2h --local=false \ + --num_msgs=200 --frequency=25 "$LOGDIR/pub_g2h.log" 2>&1 & + PIDS+=($!) + # h2g: host publishes. + "$PUB" --socket="$HOST_SOCKET" --channel=h2g --local=false \ + --num_msgs=200 --frequency=25 "$LOGDIR/pub_h2g.log" 2>&1 & + PIDS+=($!) + sleep "$PUB_TIME" + + local rc=0 + note "Results" + check_dir "g2h (guest -> host)" "$LOGDIR/sub_g2h.log" || rc=1 + check_dir "h2g (host -> guest)" "$LOGDIR/sub_h2g.log" || rc=1 + return $rc +} + +printf 'Cross-host bridge test (mode=%s, logs in %s)\n' "$MODE" "$LOGDIR" +case "$MODE" in + native) run_native; RC=$? ;; + emulator) run_emulator; RC=$? ;; + *) echo "unknown mode: $MODE (use native|emulator)"; exit 2 ;; +esac + +note "Done (logs in $LOGDIR)" +exit "$RC" diff --git a/manual_tests/pub.cc b/manual_tests/pub.cc index e69fc22..8960837 100644 --- a/manual_tests/pub.cc +++ b/manual_tests/pub.cc @@ -13,9 +13,16 @@ ABSL_FLAG(int, num_msgs, 1, "Number of messages to send"); ABSL_FLAG(double, frequency, 0, "Freqency to send at (Hz)"); ABSL_FLAG(bool, reliable, false, "Use reliable transport"); ABSL_FLAG(int, num_slots, 5, "Number of slots in channel"); +ABSL_FLAG(bool, local, true, + "Restrict the channel to the local machine. Set to false to allow " + "the channel to be bridged to other servers."); +ABSL_FLAG(std::string, channel, "test", "Channel name to publish on"); int main(int argc, char **argv) { absl::ParseCommandLine(argc, argv); + // Line-buffer stdout so progress is visible (and not lost on termination) + // when output is redirected to a file or pipe, e.g. in scripted tests. + setvbuf(stdout, nullptr, _IOLBF, 0); subspace::Client client; absl::Status init_status = client.Init(absl::GetFlag(FLAGS_socket)); @@ -26,10 +33,12 @@ int main(int argc, char **argv) { } bool reliable = absl::GetFlag(FLAGS_reliable); int num_slots = absl::GetFlag(FLAGS_num_slots); + bool local = absl::GetFlag(FLAGS_local); + std::string channel = absl::GetFlag(FLAGS_channel); absl::StatusOr pub = client.CreatePublisher( - "test", 256, num_slots, - subspace::PublisherOptions().SetLocal(true).SetReliable(reliable)); + channel, 256, num_slots, + subspace::PublisherOptions().SetLocal(local).SetReliable(reliable)); if (!pub.ok()) { fprintf(stderr, "Can't create publisher: %s\n", pub.status().ToString().c_str()); diff --git a/manual_tests/sub.cc b/manual_tests/sub.cc index 297747e..2aca698 100644 --- a/manual_tests/sub.cc +++ b/manual_tests/sub.cc @@ -11,10 +11,14 @@ ABSL_FLAG(std::string, socket, "/tmp/subspace", "Name of Unix socket to listen on"); ABSL_FLAG(bool, reliable, false, "Use reliable transport"); +ABSL_FLAG(std::string, channel, "test", "Channel name to subscribe to"); int main(int argc, char **argv) { absl::ParseCommandLine(argc, argv); signal(SIGPIPE, SIG_IGN); + // Line-buffer stdout so progress is visible (and not lost on termination) + // when output is redirected to a file or pipe, e.g. in scripted tests. + setvbuf(stdout, nullptr, _IOLBF, 0); subspace::Client client; @@ -24,9 +28,10 @@ int main(int argc, char **argv) { exit(1); } bool reliable = absl::GetFlag(FLAGS_reliable); + std::string channel = absl::GetFlag(FLAGS_channel); absl::StatusOr sub = client.CreateSubscriber( - "test", subspace::SubscriberOptions().SetReliable(reliable)); + channel, subspace::SubscriberOptions().SetReliable(reliable)); if (!sub.ok()) { fprintf(stderr, "Can't create subscriber: %s\n", sub.status().ToString().c_str()); diff --git a/plugins/split_buffer_free_test_plugin.cc b/plugins/split_buffer_free_test_plugin.cc index afacee7..7944b15 100644 --- a/plugins/split_buffer_free_test_plugin.cc +++ b/plugins/split_buffer_free_test_plugin.cc @@ -37,8 +37,10 @@ absl::StatusOr OnFreeClientBuffer( subspace::Server & /*s*/, const subspace::ClientBufferHandleMetadata &metadata, subspace::PluginContext * /*ctx*/) { - if (metadata.allocator != "split_callback" && - metadata.allocator != "split_buffer_free_test") { + if (metadata.allocator != + subspace::ClientBufferAllocatorKind::kSplitCallback && + metadata.allocator != + subspace::ClientBufferAllocatorKind::kSplitBufferFreeTest) { return false; } @@ -53,7 +55,8 @@ absl::StatusOr OnFreeClientBuffer( } log << metadata.channel_name << " " << metadata.session_id << " " << metadata.buffer_index << " " << metadata.slot_id << " " - << metadata.handle << " " << metadata.allocator << "\n"; + << metadata.handle << " " + << subspace::ClientBufferAllocatorName(metadata.allocator) << "\n"; return true; } diff --git a/proto/Android.bp b/proto/Android.bp deleted file mode 100644 index 655b8f7..0000000 --- a/proto/Android.bp +++ /dev/null @@ -1,17 +0,0 @@ -// 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 e44b032..46036cc 100644 --- a/proto/CMakeLists.txt +++ b/proto/CMakeLists.txt @@ -4,8 +4,9 @@ cmake_minimum_required(VERSION 3.15) -# Protobuf is already fetched by the parent CMakeLists.txt via FetchContent -# The targets like protobuf::libprotobuf and protobuf::protoc are available directly +# Protobuf is already fetched by the parent CMakeLists.txt via FetchContent. +# Native builds use protobuf::protoc directly. Cross-compiles use a host-native +# protoc that must match the fetched protobuf version. # Include FetchContent to get protobuf source directory for well-known types include(FetchContent) @@ -28,32 +29,40 @@ 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") -# 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)" + find_program(PROTOC_EXECUTABLE protoc REQUIRED) + execute_process( + COMMAND ${PROTOC_EXECUTABLE} --version + OUTPUT_VARIABLE PROTOC_VERSION_OUTPUT + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE PROTOC_VERSION_RESULT + ) + if(NOT PROTOC_VERSION_RESULT EQUAL 0) + message(FATAL_ERROR "Failed to run host protoc at ${PROTOC_EXECUTABLE}") + endif() + string(REGEX MATCH "[0-9]+(\\.[0-9]+)+" PROTOC_VERSION "${PROTOC_VERSION_OUTPUT}") + if(NOT PROTOC_VERSION) + message(FATAL_ERROR "Could not parse host protoc version from: ${PROTOC_VERSION_OUTPUT}") + endif() + if(NOT PROTOC_VERSION VERSION_EQUAL SUBSPACE_PROTOBUF_VERSION) + message(FATAL_ERROR + "Host protoc version ${PROTOC_VERSION} does not match fetched protobuf " + "version ${SUBSPACE_PROTOBUF_VERSION}. Pass a matching compiler with " + "-DPROTOC_EXECUTABLE=/path/to/protoc." ) endif() + message(STATUS "Cross-compiling: using host protoc ${PROTOC_VERSION} at ${PROTOC_EXECUTABLE}") + 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)" + ) 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 $ @@ -75,11 +84,8 @@ add_library(subspace_proto STATIC # 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} - ${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 deleted file mode 100644 index 5a09bc9..0000000 --- a/proto/subspace.pb.cc +++ /dev/null @@ -1,23058 +0,0 @@ -// 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 deleted file mode 100644 index 63e2aa2..0000000 --- a/proto/subspace.pb.h +++ /dev/null @@ -1,25794 +0,0 @@ -// 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/proto/subspace.proto b/proto/subspace.proto index 25bf595..23ac6e9 100644 --- a/proto/subspace.proto +++ b/proto/subspace.proto @@ -31,13 +31,13 @@ message CreatePublisherRequest { bool is_bridge = 6; // This publisher is for the bridge. bytes type = 7; // Type of data carried on channel. bool is_fixed_size = 8; - bool for_tunnel = 15; - string mux = 9; - int32 vchan_id = 10; - bool notify_retirement = 11; // Notify publisher of slot retirement. - int32 checksum_size = 12; // Bytes reserved for checksum. - int32 metadata_size = 13; // Bytes reserved for user metadata. - int32 publisher_id = 14; // -1 for new, >= 0 to reclaim existing. + bool for_tunnel = 9; + string mux = 10; + int32 vchan_id = 11; + bool notify_retirement = 12; // Notify publisher of slot retirement. + int32 checksum_size = 13; // Bytes reserved for checksum. + int32 metadata_size = 14; // Bytes reserved for user metadata. + int32 publisher_id = 15; // -1 for new, >= 0 to reclaim existing. bool use_split_buffers = 16; // Prefixes and payload slots are separate. int32 max_publishers = 17; // 0 means no explicit publisher limit. bool split_buffers_over_bridge = 18; // Remote bridge publisher uses split buffers. @@ -55,8 +55,8 @@ message CreatePublisherResponse { int32 num_sub_updates = 9; bytes type = 10; int32 vchan_id = 11; - int32 retirement_fd_index = 14; // My retirement fd index (read end) - repeated int32 retirement_fd_indexes = 15; // Write end of all retirement fds. + int32 retirement_fd_index = 12; // My retirement fd index (read end) + repeated int32 retirement_fd_indexes = 13; // Write end of all retirement fds. } // This is used both to create a new subscriber and to reload @@ -69,9 +69,9 @@ message CreateSubscriberRequest { bool is_bridge = 4; // This subscriber is for the bridge. bytes type = 5; // Type of data carried on channel. int32 max_active_messages = 6; // Max number of active message objects. - bool for_tunnel = 9; - string mux = 7; - int32 vchan_id = 8; + bool for_tunnel = 7; + string mux = 8; + int32 vchan_id = 9; } message CreateSubscriberResponse { @@ -136,6 +136,14 @@ message GetChannelStatsResponse { repeated ChannelStatsProto channels = 2; } +enum ClientBufferAllocator { + CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED = 0; + CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD = 1; + CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM = 2; + CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK = 3; + CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST = 4; +} + message ClientBufferHandleMetadataProto { string channel_name = 1; uint64 session_id = 2; @@ -147,15 +155,20 @@ message ClientBufferHandleMetadataProto { uint64 handle = 8; string shadow_file = 9; string object_name = 10; - string allocator = 11; - string pool_id = 12; - bool cache_enabled = 13; - uint32 alignment = 14; - google.protobuf.Any allocator_metadata = 15; + ClientBufferAllocator allocator = 11; } message RegisterClientBufferRequest { ClientBufferHandleMetadataProto metadata = 1; + // Optional backing FD sent via SCM_RIGHTS. If has_fd is true, fd_index is an + // index into the received FD list. Path-backed/shared-name allocators leave + // has_fd false. + bool has_fd = 2; + int32 fd_index = 3; +} + +message RegisterClientBufferResponse { + string error = 1; } message UnregisterClientBufferRequest { @@ -164,6 +177,18 @@ message UnregisterClientBufferRequest { uint32 buffer_index = 3; } +message GetClientBuffersRequest { + string channel_name = 1; + uint64 session_id = 2; + uint32 buffer_index = 3; +} + +message GetClientBuffersResponse { + string error = 1; + repeated ClientBufferHandleMetadataProto metadata = 2; + repeated int32 fd_indexes = 3; +} + message Request { oneof request { InitRequest init = 1; @@ -172,10 +197,11 @@ message Request { GetTriggersRequest get_triggers = 4; RemovePublisherRequest remove_publisher = 5; RemoveSubscriberRequest remove_subscriber = 6; - GetChannelInfoRequest get_channel_info = 9; - GetChannelStatsRequest get_channel_stats = 10; - RegisterClientBufferRequest register_client_buffer = 11; - UnregisterClientBufferRequest unregister_client_buffer = 12; + GetChannelInfoRequest get_channel_info = 7; + GetChannelStatsRequest get_channel_stats = 8; + RegisterClientBufferRequest register_client_buffer = 9; + UnregisterClientBufferRequest unregister_client_buffer = 10; + GetClientBuffersRequest get_client_buffers = 11; } } @@ -187,8 +213,10 @@ message Response { GetTriggersResponse get_triggers = 4; RemovePublisherResponse remove_publisher = 5; RemoveSubscriberResponse remove_subscriber = 6; - GetChannelInfoResponse get_channel_info = 9; - GetChannelStatsResponse get_channel_stats = 10; + GetChannelInfoResponse get_channel_info = 7; + GetChannelStatsResponse get_channel_stats = 8; + GetClientBuffersResponse get_client_buffers = 9; + RegisterClientBufferResponse register_client_buffer = 10; } } @@ -204,13 +232,13 @@ message ChannelInfoProto { int32 num_bridge_pubs = 7; // Number of publishers that are bridges. int32 num_bridge_subs = 8; // Number of subscribers that are bridges. bool is_reliable = 9; // True if channel is reliable. - int32 num_tunnel_pubs = 13; // Number of publishers that are tunnels. - int32 num_tunnel_subs = 14; // Number of subscribers that are tunnels. - bool is_virtual = 10; // True if channel is virtual. + int32 num_tunnel_pubs = 10; // Number of publishers that are tunnels. + int32 num_tunnel_subs = 11; // Number of subscribers that are tunnels. + bool is_virtual = 12; // True if channel is virtual. // Only if is_virtual is true. - int32 vchan_id = 11; // Virtual channel ID. - string mux = 12; + int32 vchan_id = 13; // Virtual channel ID. + string mux = 14; } // This is published to the /subspace/ChannelDirectory channel. @@ -488,6 +516,9 @@ message ShadowStateDone { message ShadowRegisterClientBuffer { ClientBufferHandleMetadataProto metadata = 1; + // Optional backing FD sent via SCM_RIGHTS. + bool has_fd = 2; + int32 fd_index = 3; } message ShadowUnregisterClientBuffer { diff --git a/rpc/client/client_test.cc b/rpc/client/client_test.cc index d483610..402aae3 100644 --- a/rpc/client/client_test.cc +++ b/rpc/client/client_test.cc @@ -58,7 +58,11 @@ class ClientTest : public ::testing::Test { return; } printf("Starting Subspace server\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]; @@ -118,7 +122,11 @@ class ClientTest : public ::testing::Test { }; co::CoroutineScheduler ClientTest::scheduler_; +#if defined(__ANDROID__) +std::string ClientTest::socket_ = "/data/local/tmp/subspace"; +#else std::string ClientTest::socket_ = "/tmp/subspace"; +#endif int ClientTest::server_pipe_[2]; std::unique_ptr ClientTest::server_; std::thread ClientTest::server_thread_; diff --git a/rpc/server/server_test.cc b/rpc/server/server_test.cc index 4d18245..9497809 100644 --- a/rpc/server/server_test.cc +++ b/rpc/server/server_test.cc @@ -55,7 +55,11 @@ class ServerTest : public ::testing::Test { return; } printf("Starting Subspace server\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]; @@ -115,7 +119,11 @@ class ServerTest : public ::testing::Test { }; co::CoroutineScheduler ServerTest::scheduler_; +#if defined(__ANDROID__) +std::string ServerTest::socket_ = "/data/local/tmp/subspace"; +#else std::string ServerTest::socket_ = "/tmp/subspace"; +#endif int ServerTest::server_pipe_[2]; std::unique_ptr ServerTest::server_; std::thread ServerTest::server_thread_; diff --git a/rpc/test/rpc_test.cc b/rpc/test/rpc_test.cc index 2a3b380..6793188 100644 --- a/rpc/test/rpc_test.cc +++ b/rpc/test/rpc_test.cc @@ -59,7 +59,11 @@ class RpcTest : public ::testing::Test { return; } printf("Starting Subspace server\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]; @@ -119,7 +123,11 @@ class RpcTest : public ::testing::Test { }; co::CoroutineScheduler RpcTest::scheduler_; +#if defined(__ANDROID__) +std::string RpcTest::socket_ = "/data/local/tmp/subspace"; +#else std::string RpcTest::socket_ = "/tmp/subspace"; +#endif int RpcTest::server_pipe_[2]; std::unique_ptr RpcTest::server_; std::thread RpcTest::server_thread_; diff --git a/rust_client/src/client.rs b/rust_client/src/client.rs index fbb7873..48c40da 100644 --- a/rust_client/src/client.rs +++ b/rust_client/src/client.rs @@ -1277,10 +1277,21 @@ fn register_pending_client_buffers(client: &mut ClientInner, channel: &mut Chann request: Some(proto::request::Request::RegisterClientBuffer( proto::RegisterClientBufferRequest { metadata: Some(metadata), + has_fd: false, + fd_index: 0, }, )), }; client.socket.send_request(&req)?; + let (resp, _fds) = client.socket.receive_response()?; + match resp.response { + Some(proto::response::Response::RegisterClientBuffer(r)) => { + if !r.error.is_empty() { + return Err(SubspaceError::ServerError(r.error)); + } + } + _ => return Err(SubspaceError::Internal("Unexpected response".into())), + } } Ok(()) } diff --git a/rust_client/src/split_buffer.rs b/rust_client/src/split_buffer.rs index b0ff08d..170fc2a 100644 --- a/rust_client/src/split_buffer.rs +++ b/rust_client/src/split_buffer.rs @@ -74,6 +74,14 @@ impl std::fmt::Debug for SplitBufferCallbacks { impl SplitBufferMetadata { pub fn to_proto(&self, allocator: &str) -> proto::ClientBufferHandleMetadataProto { + let allocator = match allocator { + "split_shm" => proto::ClientBufferAllocator::SplitShm as i32, + "split_callback" => proto::ClientBufferAllocator::SplitCallback as i32, + "split_buffer_free_test" => { + proto::ClientBufferAllocator::SplitBufferFreeTest as i32 + } + _ => proto::ClientBufferAllocator::Unspecified as i32, + }; proto::ClientBufferHandleMetadataProto { channel_name: self.channel_name.clone(), session_id: self.session_id, @@ -85,11 +93,7 @@ impl SplitBufferMetadata { handle: self.handle, shadow_file: self.shadow_file.clone(), object_name: self.object_name.clone(), - allocator: allocator.to_string(), - pool_id: String::new(), - cache_enabled: false, - alignment: 0, - allocator_metadata: None, + allocator, } } } diff --git a/server/Android.bp b/server/Android.bp index e3a4c69..410318f 100644 --- a/server/Android.bp +++ b/server/Android.bp @@ -12,31 +12,19 @@ cc_library_static { "shadow_replicator.cc", ], export_include_dirs: ["."], - local_include_dirs: [".."], + include_dirs: ["external/subspace"], static_libs: [ "libsubspace_common", "libsubspace_proto", "libcoroutines", "libcpp_toolbelt", + "libabsl", ], shared_libs: [ "libsubspace_client", - "libprotobuf-cpp-lite", + "libprotobuf-cpp-full", "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 { @@ -49,24 +37,12 @@ cc_binary { "libsubspace_proto", "libcoroutines", "libcpp_toolbelt", + "libabsl", ], shared_libs: [ "libsubspace_client", - "libprotobuf-cpp-lite", + "libprotobuf-cpp-full", "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/client_handler.cc b/server/client_handler.cc index 4a92c5e..cbe2f75 100644 --- a/server/client_handler.cc +++ b/server/client_handler.cc @@ -9,6 +9,39 @@ namespace subspace { namespace { + +ClientBufferAllocatorKind FromProtoAllocator(ClientBufferAllocator allocator) { + switch (allocator) { + case CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD: + return ClientBufferAllocatorKind::kAndroidMemfd; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM: + return ClientBufferAllocatorKind::kSplitShm; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK: + return ClientBufferAllocatorKind::kSplitCallback; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST: + return ClientBufferAllocatorKind::kSplitBufferFreeTest; + case CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED: + default: + return ClientBufferAllocatorKind::kUnspecified; + } +} + +ClientBufferAllocator ToProtoAllocator(ClientBufferAllocatorKind allocator) { + switch (allocator) { + case ClientBufferAllocatorKind::kAndroidMemfd: + return CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD; + case ClientBufferAllocatorKind::kSplitShm: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM; + case ClientBufferAllocatorKind::kSplitCallback: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK; + case ClientBufferAllocatorKind::kSplitBufferFreeTest: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST; + case ClientBufferAllocatorKind::kUnspecified: + default: + return CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED; + } +} + ClientBufferHandleMetadata FromProto(const ClientBufferHandleMetadataProto &proto) { ClientBufferHandleMetadata metadata; @@ -22,14 +55,25 @@ FromProto(const ClientBufferHandleMetadataProto &proto) { metadata.handle = static_cast(proto.handle()); metadata.shadow_file = proto.shadow_file(); metadata.object_name = proto.object_name(); - metadata.allocator = proto.allocator(); - metadata.pool_id = proto.pool_id(); - metadata.cache_enabled = proto.cache_enabled(); - metadata.alignment = proto.alignment(); - metadata.allocator_metadata = proto.allocator_metadata(); + metadata.allocator = FromProtoAllocator(proto.allocator()); return metadata; } +void ToProto(const ClientBufferHandleMetadata &metadata, + ClientBufferHandleMetadataProto *proto) { + proto->set_channel_name(metadata.channel_name); + proto->set_session_id(metadata.session_id); + proto->set_buffer_index(metadata.buffer_index); + proto->set_slot_id(metadata.slot_id); + proto->set_is_prefix(metadata.is_prefix); + proto->set_full_size(metadata.full_size); + proto->set_allocation_size(metadata.allocation_size); + proto->set_handle(static_cast(metadata.handle)); + proto->set_shadow_file(metadata.shadow_file); + proto->set_object_name(metadata.object_name); + proto->set_allocator(ToProtoAllocator(metadata.allocator)); +} + SplitBufferOptions FromPublisherSplitBufferRequest(const CreatePublisherRequest &req) { return {.use_split_buffers = req.use_split_buffers(), @@ -65,16 +109,31 @@ void ClientHandler::Run() { } } + std::vector fds; + subspace::Response response; if (request.request_case() == subspace::Request::kRegisterClientBuffer) { + std::vector register_fds; + if (request.register_client_buffer().has_fd()) { + if (absl::Status s = socket_.ReceiveFds(register_fds, co::self); + !s.ok()) { + server_->logger_.Log(toolbelt::LogLevel::kError, "%s\n", + s.ToString().c_str()); + return; + } + } if (absl::Status s = - HandleRegisterClientBuffer(request.register_client_buffer()); + HandleRegisterClientBuffer(request.register_client_buffer(), + register_fds); !s.ok()) { server_->logger_.Log(toolbelt::LogLevel::kError, "%s\n", s.ToString().c_str()); + response.mutable_register_client_buffer()->set_error( + s.ToString()); + } else { + response.mutable_register_client_buffer(); } - continue; - } - if (request.request_case() == subspace::Request::kUnregisterClientBuffer) { + } else if (request.request_case() == + subspace::Request::kUnregisterClientBuffer) { if (absl::Status s = HandleUnregisterClientBuffer(request.unregister_client_buffer()); !s.ok()) { @@ -82,14 +141,12 @@ void ClientHandler::Run() { s.ToString().c_str()); } continue; - } - - std::vector fds; - subspace::Response response; - if (absl::Status s = HandleMessage(request, response, fds); !s.ok()) { - server_->logger_.Log(toolbelt::LogLevel::kError, "%s\n", - s.ToString().c_str()); - return; + } else { + if (absl::Status s = HandleMessage(request, response, fds); !s.ok()) { + server_->logger_.Log(toolbelt::LogLevel::kError, "%s\n", + s.ToString().c_str()); + return; + } } size_t msglen = response.ByteSizeLong(); @@ -155,8 +212,13 @@ ClientHandler::HandleMessage(const subspace::Request &req, resp.mutable_get_channel_stats(), fds); break; + case subspace::Request::kGetClientBuffers: + HandleGetClientBuffers(req.get_client_buffers(), + resp.mutable_get_client_buffers(), fds); + break; + case subspace::Request::kRegisterClientBuffer: - return HandleRegisterClientBuffer(req.register_client_buffer()); + return HandleRegisterClientBuffer(req.register_client_buffer(), fds); case subspace::Request::kUnregisterClientBuffer: return HandleUnregisterClientBuffer(req.unregister_client_buffer()); @@ -168,7 +230,8 @@ ClientHandler::HandleMessage(const subspace::Request &req, } absl::Status ClientHandler::HandleRegisterClientBuffer( - const subspace::RegisterClientBufferRequest &req) { + const subspace::RegisterClientBufferRequest &req, + std::vector &fds) { ClientBufferHandleMetadata metadata = FromProto(req.metadata()); if (metadata.session_id != server_->GetSessionId()) { return absl::InternalError(absl::StrFormat( @@ -185,8 +248,21 @@ absl::Status ClientHandler::HandleRegisterClientBuffer( if (channel->IsVirtual()) { channel = static_cast(channel)->GetMux(); } - channel->RegisterClientBuffer(metadata); + toolbelt::FileDescriptor fd; + if (req.has_fd() && static_cast(req.fd_index()) < fds.size()) { + fd = std::move(fds[size_t(req.fd_index())]); + } + channel->RegisterClientBuffer(metadata, std::move(fd)); server_->ForEachShadow([&](const std::unique_ptr &shadow) { + const auto matches = + channel->FindClientBuffers(metadata.session_id, metadata.buffer_index); + for (const RegisteredClientBuffer *buffer : matches) { + if (buffer->metadata.slot_id == metadata.slot_id && + buffer->metadata.is_prefix == metadata.is_prefix) { + shadow->SendRegisterClientBuffer(buffer->metadata, buffer->fd); + return; + } + } shadow->SendRegisterClientBuffer(metadata); }); return absl::OkStatus(); @@ -212,6 +288,31 @@ absl::Status ClientHandler::HandleUnregisterClientBuffer( return absl::OkStatus(); } +void ClientHandler::HandleGetClientBuffers( + const subspace::GetClientBuffersRequest &req, + subspace::GetClientBuffersResponse *response, + std::vector &fds) { + ServerChannel *channel = server_->FindChannel(req.channel_name()); + if (channel == nullptr) { + response->set_error(absl::StrFormat("Unknown channel %s", + req.channel_name())); + return; + } + if (channel->IsVirtual()) { + channel = static_cast(channel)->GetMux(); + } + for (const RegisteredClientBuffer *buffer : + channel->FindClientBuffers(req.session_id(), req.buffer_index())) { + ToProto(buffer->metadata, response->add_metadata()); + if (buffer->fd.Valid()) { + response->add_fd_indexes(static_cast(fds.size())); + fds.push_back(buffer->fd); + } else { + response->add_fd_indexes(-1); + } + } +} + void ClientHandler::HandleInit(const subspace::InitRequest &req, subspace::InitResponse *response, std::vector &fds) { diff --git a/server/client_handler.h b/server/client_handler.h index 3848f10..b67bb84 100644 --- a/server/client_handler.h +++ b/server/client_handler.h @@ -64,9 +64,13 @@ class ClientHandler { subspace::GetChannelStatsResponse *response, std::vector &fds); absl::Status - HandleRegisterClientBuffer(const subspace::RegisterClientBufferRequest &req); + HandleRegisterClientBuffer(const subspace::RegisterClientBufferRequest &req, + std::vector &fds); absl::Status HandleUnregisterClientBuffer( const subspace::UnregisterClientBufferRequest &req); + void HandleGetClientBuffers(const subspace::GetClientBuffersRequest &req, + subspace::GetClientBuffersResponse *response, + std::vector &fds); Server *server_; toolbelt::UnixSocket socket_; std::string client_name_; diff --git a/server/main.cc b/server/main.cc index 3d647c3..dbe3123 100644 --- a/server/main.cc +++ b/server/main.cc @@ -37,6 +37,15 @@ ABSL_FLAG(bool, bridge_ports_fallback_ephemeral, false, ABSL_FLAG(std::string, log_level, "info", "Log level"); ABSL_FLAG(std::string, interface, "", "Discovery network interface"); ABSL_FLAG(bool, local, false, "Use local computer only"); +ABSL_FLAG(bool, tcp_discovery, false, + "Use a TCP connection for discovery instead of UDP broadcast/unicast. " + "A server with --peer_address dials it; a server without one listens " + "on --disc_port. Useful across NAT (e.g. an Android emulator/VM)."); +ABSL_FLAG(std::string, bridge_advertise_address, "", + "IP address to advertise to peers for this server's bridge " + "listeners, overriding the local interface address (e.g. 127.0.0.1 " + "reached via adb forward/reverse). Bridge listeners bind to the " + "any-address when this is set."); ABSL_FLAG(int, notify_fd, -1, "File descriptor to notify of startup"); ABSL_FLAG(std::string, machine, "", "Machine name"); @@ -148,6 +157,20 @@ int main(int argc, char **argv) { if (absl::GetFlag(FLAGS_cleanup_filesystem)) { server->SetCleanupFilesystem(true); } + if (absl::GetFlag(FLAGS_tcp_discovery)) { + server->SetTcpDiscovery(true); + } + if (const std::string &bridge_advertise = + absl::GetFlag(FLAGS_bridge_advertise_address); + !bridge_advertise.empty()) { + toolbelt::InetAddress advertise_address(bridge_advertise, 0); + if (!advertise_address.Valid()) { + fprintf(stderr, "Invalid --bridge_advertise_address value '%s'\n", + bridge_advertise.c_str()); + exit(1); + } + server->SetBridgeAdvertiseAddress(advertise_address); + } // Load the plugins. Each plugin is a name:path pair. for (const auto &p : absl::GetFlag(FLAGS_plugins)) { diff --git a/server/server.cc b/server/server.cc index ecddfd8..77e7f4f 100644 --- a/server/server.cc +++ b/server/server.cc @@ -426,16 +426,27 @@ void Server::CreateShutdownTrigger() { shutdown_trigger_fd_ = std::move(*fd); } +toolbelt::SocketAddress Server::BridgeBindBase() const { + // When advertising a separate (e.g. forwarded loopback) address, bind to the + // any-address so the listener is reachable both on the local interface and + // via a forwarded loopback port. Otherwise bind to the local interface. + if (bridge_advertise_address_.Valid()) { + return toolbelt::InetAddress::AnyAddress(0); + } + return my_address_; +} + absl::Status Server::BindBridgeListener(toolbelt::StreamSocket &listener) { + toolbelt::SocketAddress bind_base = BridgeBindBase(); if (!bridge_port_range_.Enabled()) { - return listener.Bind(toolbelt::SocketAddress::AnyPort(my_address_), true); + return listener.Bind(toolbelt::SocketAddress::AnyPort(bind_base), true); } absl::Status last_status = absl::UnavailableError("no ports tried"); for (int port = bridge_port_range_.first_port; port <= bridge_port_range_.last_port; ++port) { absl::StatusOr addr = - BridgeAddressWithPort(my_address_, port); + BridgeAddressWithPort(bind_base, port); if (!addr.ok()) { return addr.status(); } @@ -450,7 +461,7 @@ absl::Status Server::BindBridgeListener(toolbelt::StreamSocket &listener) { } if (bridge_ports_fallback_to_ephemeral_) { - return listener.Bind(toolbelt::SocketAddress::AnyPort(my_address_), true); + return listener.Bind(toolbelt::SocketAddress::AnyPort(bind_base), true); } return absl::UnavailableError(absl::StrFormat( @@ -531,15 +542,8 @@ void Server::CleanupAfterSession() { "subspace_." + std::to_string(session_id_); #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()); - } - } - } + // Android uses anonymous fd-backed shared memory; there are no shm files to + // remove for a session. #elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX // Remove all files starting with "subspace_SESSION" in /tmp. These refer to @@ -583,15 +587,8 @@ void Server::CleanupAfterSession() { void Server::CleanupFilesystem() { logger_.Log(toolbelt::LogLevel::kInfo, "Cleaning up filesystem..."); #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()); - } - } - } + // Android uses anonymous fd-backed shared memory; there are no shm files to + // remove. #elif SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX // Remove all files starting with "subspace_" in /tmp. These refer to @@ -632,18 +629,6 @@ 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 @@ -782,10 +767,9 @@ absl::Status Server::Run() { if (recovered) { for (auto &[name, ch] : channels_) { shadow->SendCreateChannel(ch.get()); - for (const ClientBufferHandleMetadata &metadata : - ch->ClientBuffers()) { - shadow->SendRegisterClientBuffer(metadata); - } + ch->ForEachClientBuffer([&](const RegisteredClientBuffer &buffer) { + shadow->SendRegisterClientBuffer(buffer.metadata, buffer.fd); + }); for (auto &[uid, user] : ch->GetUsers()) { if (user == nullptr) { continue; @@ -845,35 +829,51 @@ absl::Status Server::Run() { if (absl::Status s = FindIPAddresses(interface_, ip_addr, bcast_addr, logger_); !s.ok()) { - return s; - } - logger_.Log(toolbelt::LogLevel::kInfo, "IPv4: %s, Broadcast: %s", - ip_addr.ToString().c_str(), bcast_addr.ToString().c_str()); - - my_address_ = ip_addr; - // Bind the discovery transmitter to the network and any free - // port on the requested interface. - if (absl::Status s = discovery_transmitter_.Bind(ip_addr); !s.ok()) { - return s; + // TCP discovery does not need a broadcast-capable interface, and when a + // bridge advertise address is configured we don't need the local + // interface address either. Treat the failure as non-fatal in that + // case so loopback/NAT setups (e.g. an Android emulator) can run. + if (tcp_discovery_ && bridge_advertise_address_.Valid()) { + logger_.Log(toolbelt::LogLevel::kWarning, + "Could not determine local interface address (%s); " + "continuing with TCP discovery and advertised bridge " + "address %s", + s.ToString().c_str(), + bridge_advertise_address_.ToString().c_str()); + } else { + return s; + } + } else { + logger_.Log(toolbelt::LogLevel::kInfo, "IPv4: %s, Broadcast: %s", + ip_addr.ToString().c_str(), bcast_addr.ToString().c_str()); + my_address_ = ip_addr; } - if (peer_address_.Valid()) { - // If peer address is supplied, use it. - discovery_addr_ = peer_address_; - } else { - // Otherwise use the broadcast address. - discovery_addr_ = bcast_addr; - discovery_addr_.SetPort(discovery_peer_port_); - if (absl::Status s = discovery_transmitter_.SetBroadcast(); !s.ok()) { + if (!tcp_discovery_) { + // Bind the discovery transmitter to the network and any free + // port on the requested interface. + if (absl::Status s = discovery_transmitter_.Bind(ip_addr); !s.ok()) { return s; } - } - // Open the discovery receiver socket. - if (absl::Status s = discovery_receiver_.Bind( - toolbelt::InetAddress::AnyAddress(discovery_port_)); - !s.ok()) { - return s; + if (peer_address_.Valid()) { + // If peer address is supplied, use it. + discovery_addr_ = peer_address_; + } else { + // Otherwise use the broadcast address. + discovery_addr_ = bcast_addr; + discovery_addr_.SetPort(discovery_peer_port_); + if (absl::Status s = discovery_transmitter_.SetBroadcast(); !s.ok()) { + return s; + } + } + + // Open the discovery receiver socket. + if (absl::Status s = discovery_receiver_.Bind( + toolbelt::InetAddress::AnyAddress(discovery_port_)); + !s.ok()) { + return s; + } } } @@ -902,10 +902,26 @@ absl::Status Server::Run() { } if (!local_) { - // Start the discovery receiver coroutine. - scheduler_.Spawn([this]() { DiscoveryReceiverCoroutine(); }, - {.name = "Discovery receiver", - .interrupt_fd = shutdown_trigger_fd_.GetPollFd().Fd()}); + if (tcp_discovery_) { + // TCP discovery: a server with a peer address dials it; otherwise we + // listen for an incoming discovery connection. + if (peer_address_.Valid()) { + scheduler_.Spawn( + [this]() { DiscoveryConnectorCoroutine(); }, + {.name = "Discovery connector", + .interrupt_fd = shutdown_trigger_fd_.GetPollFd().Fd()}); + } else { + scheduler_.Spawn( + [this]() { DiscoveryListenerCoroutine(); }, + {.name = "Discovery listener", + .interrupt_fd = shutdown_trigger_fd_.GetPollFd().Fd()}); + } + } else { + // Start the discovery receiver coroutine. + scheduler_.Spawn([this]() { DiscoveryReceiverCoroutine(); }, + {.name = "Discovery receiver", + .interrupt_fd = shutdown_trigger_fd_.GetPollFd().Fd()}); + } // Start the gratuitous Advertiser coroutine. This sends Advertise messages // every 5 seconds. @@ -1124,8 +1140,9 @@ absl::Status Server::RecoverFromShadow(RecoveredState &state) { !s.ok()) { return s; } - for (ClientBufferHandleMetadata &metadata : rch.client_buffers) { - channel->RegisterClientBuffer(std::move(metadata)); + for (RegisteredClientBuffer &buffer : rch.client_buffers) { + channel->RegisterClientBuffer(std::move(buffer.metadata), + std::move(buffer.fd)); } for (auto &rpub : rch.publishers) { @@ -1337,23 +1354,14 @@ void Server::SendQuery(const std::string &channel_name) { logger_.Log(toolbelt::LogLevel::kDebug, "Sending Query %s with discovery port %d", channel_name.c_str(), discovery_port_); - char buffer[kDiscoveryBufferSize]; Discovery disc; disc.set_server_id(server_id_); disc.set_port(discovery_port_); auto *query = disc.mutable_query(); query->set_channel_name(channel_name); - bool ok = disc.SerializeToArray(buffer, sizeof(buffer)); - if (!ok) { - logger_.Log(toolbelt::LogLevel::kError, - "Failed to serialize Query message"); - return; - } - int64_t length = disc.ByteSizeLong(); - absl::Status s = - discovery_transmitter_.SendTo(discovery_addr_, buffer, length); - if (!s.ok()) { + if (absl::Status s = TransmitDiscovery(disc, discovery_addr_); + !s.ok()) { logger_.Log(toolbelt::LogLevel::kError, "Failed to send Query: %s", s.ToString().c_str()); return; @@ -1374,7 +1382,6 @@ void Server::SendAdvertise(const std::string &channel_name, bool reliable) { logger_.Log(toolbelt::LogLevel::kDebug, "Sending Advertise %s with discovery port %d", channel_name.c_str(), discovery_port_); - char buffer[kDiscoveryBufferSize]; Discovery disc; disc.set_server_id(server_id_); disc.set_port(discovery_port_); @@ -1385,16 +1392,8 @@ void Server::SendAdvertise(const std::string &channel_name, bool reliable) { advertise->set_split_buffers( ChannelUsesSplitBuffersOverBridge(it->second.get())); } - bool ok = disc.SerializeToArray(buffer, sizeof(buffer)); - if (!ok) { - logger_.Log(toolbelt::LogLevel::kError, - "Failed to serialize Advertise message"); - return; - } - int64_t length = disc.ByteSizeLong(); - absl::Status s = - discovery_transmitter_.SendTo(discovery_addr_, buffer, length); - if (!s.ok()) { + if (absl::Status s = TransmitDiscovery(disc, discovery_addr_); + !s.ok()) { logger_.Log(toolbelt::LogLevel::kError, "Failed to send Advertise: %s", s.ToString().c_str()); return; @@ -1404,6 +1403,193 @@ void Server::SendAdvertise(const std::string &channel_name, bool reliable) { .interrupt_fd = shutdown_trigger_fd_.GetPollFd().Fd()}); } +absl::Status Server::TransmitDiscovery(const Discovery &disc, + const toolbelt::InetAddress &udp_dest) { + if (tcp_discovery_) { + int64_t length = disc.ByteSizeLong(); + // SendMessage writes a 4-byte length prefix immediately before the + // payload, so reserve room for it at the front of the buffer. + std::vector buffer(sizeof(int32_t) + length); + if (!disc.SerializeToArray(buffer.data() + sizeof(int32_t), + static_cast(length))) { + return absl::InternalError("Failed to serialize discovery message"); + } + // Copy the connection list so a send that drops a connection can't + // invalidate the iterator. Writes are blocking (no coroutine yield) so + // messages from different coroutines can't interleave on a connection. + auto connections = discovery_connections_; + for (const auto &conn : connections) { + absl::StatusOr n = + conn->socket->SendMessage(buffer.data() + sizeof(int32_t), length); + if (!n.ok()) { + logger_.Log(toolbelt::LogLevel::kError, + "Failed to send discovery message to %s: %s", + conn->remote.ToString().c_str(), n.status().ToString().c_str()); + } + } + return absl::OkStatus(); + } + + char buffer[kDiscoveryBufferSize]; + if (!disc.SerializeToArray(buffer, sizeof(buffer))) { + return absl::InternalError("Failed to serialize discovery message"); + } + return discovery_transmitter_.SendTo(udp_dest, buffer, disc.ByteSizeLong()); +} + +void Server::AddDiscoveryConnection(std::shared_ptr conn) { + discovery_connections_.insert(std::move(conn)); +} + +void Server::RemoveDiscoveryConnection( + const std::shared_ptr &conn) { + discovery_connections_.erase(conn); +} + +void Server::AdvertiseAllChannels() { + for (auto &[name, ch] : channels_) { + if (!ch->IsLocal() && !ch->IsBridgePublisher()) { + SendAdvertise(name, ch->IsReliable()); + } + } +} + +// Reads length-delimited Discovery protobufs from a single TCP discovery +// connection and dispatches them to the same handlers used by UDP discovery. +// Returns when the connection is closed or fails. +void Server::DiscoveryConnectionReaderLoop( + std::shared_ptr conn) { + char buffer[kDiscoveryBufferSize]; + for (;;) { + absl::StatusOr n = + conn->socket->ReceiveMessage(buffer, sizeof(buffer), co::self); + if (!n.ok()) { + logger_.Log(toolbelt::LogLevel::kDebug, + "Discovery connection to %s closed: %s", + conn->remote.ToString().c_str(), n.status().ToString().c_str()); + return; + } + if (*n == 0) { + logger_.Log(toolbelt::LogLevel::kDebug, + "Discovery connection to %s closed by peer", + conn->remote.ToString().c_str()); + return; + } + Discovery disc; + if (!disc.ParseFromArray(buffer, static_cast(*n))) { + logger_.Log(toolbelt::LogLevel::kError, + "Failed to parse discovery message"); + continue; + } + if (disc.server_id() == server_id_) { + continue; + } + // Build the peer address used as a bridge dedup key, mirroring the UDP + // path where the sender port is replaced by the advertised discovery port. + toolbelt::InetAddress sender = conn->remote; + sender.SetPort(disc.port()); + logger_.Log(toolbelt::LogLevel::kDebug, "Discovery message from %s\n%s", + sender.ToString().c_str(), disc.DebugString().c_str()); + switch (disc.data_case()) { + case Discovery::kQuery: + IncomingQuery(disc.query(), sender); + break; + case Discovery::kAdvertise: + IncomingAdvertise(disc.advertise(), sender, disc.server_id()); + break; + case Discovery::kSubscribe: + IncomingSubscribe(disc.subscribe(), sender, disc.server_id()); + break; + default: + break; + } + } +} + +// Listens for an incoming TCP discovery connection and serves each one with a +// reader coroutine. Used by the server that does not have a peer address. +void Server::DiscoveryListenerCoroutine() { + toolbelt::StreamSocket listener; + if (absl::Status s = listener.Bind( + toolbelt::InetAddress::AnyAddress(discovery_port_), true); + !s.ok()) { + logger_.Log(toolbelt::LogLevel::kError, + "Failed to bind TCP discovery listener on port %d: %s", + discovery_port_, s.ToString().c_str()); + return; + } + logger_.Log(toolbelt::LogLevel::kInfo, + "Listening for TCP discovery connections on port %d", + discovery_port_); + for (;;) { + absl::StatusOr incoming = listener.Accept(co::self); + if (!incoming.ok()) { + if (shutting_down_) { + return; + } + logger_.Log(toolbelt::LogLevel::kError, + "Failed to accept discovery connection: %s", + incoming.status().ToString().c_str()); + continue; + } + auto conn = std::make_shared(); + conn->socket = + std::make_shared(std::move(*incoming)); + if (absl::StatusOr peer = + conn->socket->GetPeerName(); + peer.ok() && peer->Type() == toolbelt::SocketAddress::kAddressInet) { + conn->remote = peer->GetInetAddress(); + } + logger_.Log(toolbelt::LogLevel::kInfo, + "Accepted TCP discovery connection from %s", + conn->remote.ToString().c_str()); + AddDiscoveryConnection(conn); + // Advertise our channels right away so the peer can bridge without waiting + // for the next gratuitous advertise cycle. + AdvertiseAllChannels(); + scheduler_.Spawn( + [this, conn]() { + DiscoveryConnectionReaderLoop(conn); + RemoveDiscoveryConnection(conn); + }, + {.name = "Discovery reader", + .interrupt_fd = shutdown_trigger_fd_.GetPollFd().Fd()}); + } +} + +// Dials the configured peer for TCP discovery, retrying on failure, and serves +// the connection inline. Used by the server that has a peer address. +void Server::DiscoveryConnectorCoroutine() { + constexpr int kRetrySecs = 1; + for (;;) { + if (shutting_down_) { + return; + } + auto socket = std::make_shared(); + if (absl::Status s = socket->Connect(peer_address_); !s.ok()) { + logger_.Log(toolbelt::LogLevel::kDebug, + "TCP discovery connect to %s failed: %s; retrying", + peer_address_.ToString().c_str(), s.ToString().c_str()); + co::Sleep(kRetrySecs); + continue; + } + auto conn = std::make_shared(); + conn->socket = socket; + conn->remote = peer_address_; + logger_.Log(toolbelt::LogLevel::kInfo, + "Connected TCP discovery to %s", + peer_address_.ToString().c_str()); + AddDiscoveryConnection(conn); + AdvertiseAllChannels(); + DiscoveryConnectionReaderLoop(conn); + RemoveDiscoveryConnection(conn); + if (shutting_down_) { + return; + } + co::Sleep(kRetrySecs); + } +} + // This coroutine receives discovery messages over UDP. void Server::DiscoveryReceiverCoroutine() { char buffer[kDiscoveryBufferSize]; @@ -1515,7 +1701,9 @@ void Server::BridgeTransmitterCoroutine(ServerChannel *channel, auto *ret_addr = subscribed.mutable_retirement_socket(); switch (retirement_addr.Type()) { case toolbelt::SocketAddress::kAddressInet: { - in_addr ip_addr = retirement_addr.GetInetAddress().IpAddress(); + in_addr ip_addr = bridge_advertise_address_.Valid() + ? bridge_advertise_address_.IpAddress() + : retirement_addr.GetInetAddress().IpAddress(); ret_addr->set_address(&ip_addr, sizeof(ip_addr)); break; } @@ -1765,8 +1953,11 @@ Server::SendSubscribeMessage(const std::string &channel_name, bool reliable, auto *sub_addr = sub->mutable_receiver(); switch (receiver_addr.Type()) { case toolbelt::SocketAddress::kAddressInet: { - // IPv4 address. - in_addr ip_addr = receiver_addr.GetInetAddress().IpAddress(); + // IPv4 address. Advertise the configured bridge address if set, so a + // NAT'd peer can reach us via a forwarded loopback endpoint. + in_addr ip_addr = bridge_advertise_address_.Valid() + ? bridge_advertise_address_.IpAddress() + : receiver_addr.GetInetAddress().IpAddress(); sub_addr->set_address(&ip_addr, sizeof(ip_addr)); break; } @@ -1783,15 +1974,11 @@ Server::SendSubscribeMessage(const std::string &channel_name, bool reliable, } sub_addr->set_port(receiver_addr.Port()); - bool ok = disc.SerializeToArray(buffer, static_cast(buffer_size)); - if (!ok) { - return absl::InternalError("Failed to serialize subscribe message"); - } - int64_t length = disc.ByteSizeLong(); + (void)buffer; + (void)buffer_size; logger_.Log(toolbelt::LogLevel::kDebug, "Sending subscribe to %s: %s", publisher.ToString().c_str(), disc.DebugString().c_str()); - absl::Status s = - discovery_transmitter_.SendTo(publisher, buffer, length, co::self); + absl::Status s = TransmitDiscovery(disc, publisher); if (!s.ok()) { return absl::InternalError( absl::StrFormat("Failed to send subscribe: %s", s.ToString())); diff --git a/server/server.h b/server/server.h index 8695a64..503ee84 100644 --- a/server/server.h +++ b/server/server.h @@ -21,6 +21,7 @@ #include "toolbelt/clock.h" #include "toolbelt/fd.h" #include "toolbelt/logging.h" +#include "toolbelt/sockets.h" #include "toolbelt/triggerfd.h" #include #include @@ -113,6 +114,23 @@ class Server { void SetCleanupFilesystem(bool v) { cleanup_filesystem_ = v; } + // Use a TCP connection (instead of UDP broadcast/unicast) for discovery. + // This is useful when the two servers cannot exchange UDP datagrams + // directly, for example when one of them runs inside a NAT'd virtual + // machine or Android emulator. When enabled, a server with a peer address + // configured dials the peer; a server without one listens for an incoming + // discovery connection. + void SetTcpDiscovery(bool v) { tcp_discovery_ = v; } + + // Address to advertise to peers for this server's bridge (and retirement) + // listeners, overriding the local interface address. This lets a NAT'd + // server advertise a loopback/forwarded endpoint (e.g. 127.0.0.1 reached + // via `adb forward`/`adb reverse`). When set, bridge listeners bind to the + // any-address so the forwarded loopback port reaches them. + void SetBridgeAdvertiseAddress(const toolbelt::InetAddress &addr) { + bridge_advertise_address_ = addr; + } + void CleanupFilesystem(); void CleanupAfterSession(); @@ -159,6 +177,15 @@ class Server { friend class VirtualChannel; static constexpr size_t kDiscoveryBufferSize = 1024; + // A single TCP discovery connection to a peer server. Used only when + // tcp_discovery_ is enabled. + struct DiscoveryConnection { + std::shared_ptr socket; + // Remote address of the peer (without the discovery port, which is taken + // from each received message), used as a stable key for bridge dedup. + toolbelt::InetAddress remote; + }; + struct Plugin { Plugin(const std::string &n, void *h, std::unique_ptr i) : name(n), handle(h), interface(std::move(i)) {} @@ -187,6 +214,20 @@ class Server { void SendChannelDirectory(); void StatisticsCoroutine(); void DiscoveryReceiverCoroutine(); + void DiscoveryListenerCoroutine(); + void DiscoveryConnectorCoroutine(); + void DiscoveryConnectionReaderLoop(std::shared_ptr conn); + void AddDiscoveryConnection(std::shared_ptr conn); + void + RemoveDiscoveryConnection(const std::shared_ptr &conn); + void AdvertiseAllChannels(); + // Send a discovery message to peers. In TCP mode it is written to every + // active discovery connection; in UDP mode it is sent to udp_dest. + absl::Status TransmitDiscovery(const Discovery &disc, + const toolbelt::InetAddress &udp_dest); + // The address bridge listeners bind to: the any-address when a bridge + // advertise address is configured, otherwise the local interface address. + toolbelt::SocketAddress BridgeBindBase() const; void PublisherCoroutine(); void SendQuery(const std::string &channel_name); void SendAdvertise(const std::string &channel_name, bool reliable); @@ -250,6 +291,10 @@ class Server { int discovery_port_; int discovery_peer_port_; bool local_; + bool tcp_discovery_ = false; + toolbelt::InetAddress bridge_advertise_address_; + absl::flat_hash_set> + discovery_connections_; toolbelt::FileDescriptor notify_fd_; // Atomic only because of testing. diff --git a/server/server_channel.cc b/server/server_channel.cc index 05b0dd4..1ca8094 100644 --- a/server/server_channel.cc +++ b/server/server_channel.cc @@ -7,6 +7,12 @@ #include "server/server.h" #include #include +#if defined(__ANDROID__) +#include +#ifndef MFD_CLOEXEC +#define MFD_CLOEXEC 0x0001U +#endif +#endif #if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX && defined(__APPLE__) #include #endif @@ -28,21 +34,21 @@ static absl::StatusOr CreateSharedMemory(int id, const char *suffix, 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); + snprintf(shm_file, sizeof(shm_file), "subspace.%d.%s", id, suffix); +#ifdef __NR_memfd_create + tmpfd = static_cast(syscall( + __NR_memfd_create, shm_file, static_cast(MFD_CLOEXEC))); if (tmpfd == -1) { return absl::InternalError(absl::StrFormat( - "Failed to create temp file %s: %s", shm_file, strerror(errno))); + "Failed to create anonymous shared memory %s: %s", shm_file, + strerror(errno))); } +#else + return absl::UnimplementedError("memfd_create is not available"); +#endif 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", @@ -53,15 +59,12 @@ static absl::StatusOr CreateSharedMemory(int id, const char *suffix, 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; @@ -186,29 +189,30 @@ void ServerChannel::RemoveBuffer(uint64_t session_id, Server *server) { } for (int i = 0; i < ccb_->num_buffers; i++) { std::string filename = BufferSharedMemoryName(session_id, i); - for (const ClientBufferHandleMetadata &metadata : client_buffers_) { - if (metadata.session_id != session_id || - metadata.buffer_index != static_cast(i)) { - continue; - } - bool plugin_freed = false; - if (server != nullptr) { - absl::StatusOr freed = - server->FreeClientBufferWithPlugins(metadata); - if (freed.ok()) { - plugin_freed = *freed; + auto group = client_buffers_.find( + ClientBufferGroupKey{session_id, static_cast(i)}); + if (group != client_buffers_.end()) { + for (const auto &[slot, buffer] : group->second) { + const ClientBufferHandleMetadata &metadata = buffer.metadata; + bool plugin_freed = false; + if (server != nullptr) { + absl::StatusOr freed = + server->FreeClientBufferWithPlugins(metadata); + if (freed.ok()) { + plugin_freed = *freed; + } } - } - if (!plugin_freed && !metadata.object_name.empty()) { + 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()); + // Anonymous fd-backed Android buffers are released when the server's + // registered fd is closed. #else - (void)shm_unlink(metadata.object_name.c_str()); + (void)shm_unlink(metadata.object_name.c_str()); #endif - } - if (!metadata.shadow_file.empty()) { - (void)remove(metadata.shadow_file.c_str()); + } + if (!metadata.shadow_file.empty()) { + (void)remove(metadata.shadow_file.c_str()); + } } } #if SUBSPACE_SHMEM_MODE == SUBSPACE_SHMEM_MODE_POSIX @@ -233,16 +237,17 @@ uint64_t ServerChannel::GetVirtualMemoryUsage() const { } uint64_t split_buffer_size = 0; - for (const ClientBufferHandleMetadata &metadata : client_buffers_) { + ForEachClientBuffer([&](const RegisteredClientBuffer &buffer) { + const ClientBufferHandleMetadata &metadata = buffer.metadata; if (metadata.buffer_index >= static_cast(ccb_->num_buffers)) { - continue; + return; } if (bcb_->refs[metadata.buffer_index].load(std::memory_order_relaxed) <= 0) { - continue; + return; } split_buffer_size += metadata.allocation_size; - } + }); if (split_buffer_size == 0) { return Channel::GetVirtualMemoryUsage(); diff --git a/server/server_channel.h b/server/server_channel.h index 62bb58f..f72a10d 100644 --- a/server/server_channel.h +++ b/server/server_channel.h @@ -163,6 +163,39 @@ template inline H AbslHashValue(H h, const ChannelTransmitter &a) { return H::combine(std::move(addr_hash), a.reliable_); } +// Identifies the group of client buffers that share a (session, buffer) +// pairing. This is the key used for the partial-key lookups performed by +// FindClientBuffers and UnregisterClientBuffer. +struct ClientBufferGroupKey { + uint64_t session_id; + uint32_t buffer_index; + + bool operator==(const ClientBufferGroupKey &other) const { + return session_id == other.session_id && + buffer_index == other.buffer_index; + } + + template + friend H AbslHashValue(H h, const ClientBufferGroupKey &k) { + return H::combine(std::move(h), k.session_id, k.buffer_index); + } +}; + +// Identifies a single client buffer within a group. +struct ClientBufferSlotKey { + uint32_t slot_id; + bool is_prefix; + + bool operator==(const ClientBufferSlotKey &other) const { + return slot_id == other.slot_id && is_prefix == other.is_prefix; + } + + template + friend H AbslHashValue(H h, const ClientBufferSlotKey &k) { + return H::combine(std::move(h), k.slot_id, k.is_prefix); + } +}; + // This is a channel maintained by the server. The server creates the shared // memory for the channel and distributes the file descriptor associated with // it. @@ -272,21 +305,45 @@ class ServerChannel : public Channel { } virtual void RemoveBuffer(uint64_t session_id, Server *server = nullptr); - void RegisterClientBuffer(ClientBufferHandleMetadata metadata) { - client_buffers_.push_back(std::move(metadata)); + void RegisterClientBuffer(ClientBufferHandleMetadata metadata, + toolbelt::FileDescriptor fd = {}) { + ClientBufferGroupKey group{metadata.session_id, metadata.buffer_index}; + ClientBufferSlotKey slot{metadata.slot_id, metadata.is_prefix}; + client_buffers_[group][slot] = RegisteredClientBuffer{ + .metadata = std::move(metadata), .fd = std::move(fd)}; + } + // Invokes fn(const RegisteredClientBuffer&) for every registered buffer. The + // iteration order is unspecified. + template void ForEachClientBuffer(F &&fn) const { + for (const auto &[group, slots] : client_buffers_) { + for (const auto &[slot, buffer] : slots) { + fn(buffer); + } + } } - const std::vector &ClientBuffers() const { - return client_buffers_; + size_t NumClientBuffers() const { + size_t n = 0; + for (const auto &[group, slots] : client_buffers_) { + n += slots.size(); + } + return n; + } + std::vector + FindClientBuffers(uint64_t session_id, uint32_t buffer_index) const { + std::vector result; + auto it = + client_buffers_.find(ClientBufferGroupKey{session_id, buffer_index}); + if (it == client_buffers_.end()) { + return result; + } + result.reserve(it->second.size()); + for (const auto &[slot, buffer] : it->second) { + result.push_back(&buffer); + } + return result; } void UnregisterClientBuffer(uint64_t session_id, uint32_t buffer_index) { - client_buffers_.erase( - std::remove_if(client_buffers_.begin(), client_buffers_.end(), - [session_id, buffer_index]( - const ClientBufferHandleMetadata &metadata) { - return metadata.session_id == session_id && - metadata.buffer_index == buffer_index; - }), - client_buffers_.end()); + client_buffers_.erase(ClientBufferGroupKey{session_id, buffer_index}); } // This is true if all publishers are bridge publishers. bool IsBridgePublisher() const; @@ -377,7 +434,10 @@ class ServerChannel : public Channel { absl::flat_hash_map> users_; toolbelt::BitSet user_ids_; absl::flat_hash_map bridged_publishers_; - std::vector client_buffers_; + absl::flat_hash_map> + client_buffers_; SharedMemoryFds shared_memory_fds_; bool is_virtual_ = false; bool skip_cleanup_ = false; diff --git a/server/shadow_replicator.cc b/server/shadow_replicator.cc index 9ded4e1..2d75f18 100644 --- a/server/shadow_replicator.cc +++ b/server/shadow_replicator.cc @@ -10,6 +10,38 @@ namespace subspace { namespace { +ClientBufferAllocatorKind FromProtoAllocator(ClientBufferAllocator allocator) { + switch (allocator) { + case CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD: + return ClientBufferAllocatorKind::kAndroidMemfd; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM: + return ClientBufferAllocatorKind::kSplitShm; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK: + return ClientBufferAllocatorKind::kSplitCallback; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST: + return ClientBufferAllocatorKind::kSplitBufferFreeTest; + case CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED: + default: + return ClientBufferAllocatorKind::kUnspecified; + } +} + +ClientBufferAllocator ToProtoAllocator(ClientBufferAllocatorKind allocator) { + switch (allocator) { + case ClientBufferAllocatorKind::kAndroidMemfd: + return CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD; + case ClientBufferAllocatorKind::kSplitShm: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM; + case ClientBufferAllocatorKind::kSplitCallback: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK; + case ClientBufferAllocatorKind::kSplitBufferFreeTest: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST; + case ClientBufferAllocatorKind::kUnspecified: + default: + return CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED; + } +} + ClientBufferHandleMetadata FromProto(const ClientBufferHandleMetadataProto &proto) { ClientBufferHandleMetadata metadata; @@ -23,11 +55,7 @@ FromProto(const ClientBufferHandleMetadataProto &proto) { metadata.handle = static_cast(proto.handle()); metadata.shadow_file = proto.shadow_file(); metadata.object_name = proto.object_name(); - metadata.allocator = proto.allocator(); - metadata.pool_id = proto.pool_id(); - metadata.cache_enabled = proto.cache_enabled(); - metadata.alignment = proto.alignment(); - metadata.allocator_metadata = proto.allocator_metadata(); + metadata.allocator = FromProtoAllocator(proto.allocator()); return metadata; } @@ -43,11 +71,7 @@ void ToProto(const ClientBufferHandleMetadata &metadata, proto->set_handle(static_cast(metadata.handle)); proto->set_shadow_file(metadata.shadow_file); proto->set_object_name(metadata.object_name); - proto->set_allocator(metadata.allocator); - proto->set_pool_id(metadata.pool_id); - proto->set_cache_enabled(metadata.cache_enabled); - proto->set_alignment(metadata.alignment); - *proto->mutable_allocator_metadata() = metadata.allocator_metadata; + proto->set_allocator(ToProtoAllocator(metadata.allocator)); } } // namespace @@ -228,11 +252,18 @@ void ShadowReplicator::SendRemoveSubscriber(const std::string &channel_name, } void ShadowReplicator::SendRegisterClientBuffer( - const ClientBufferHandleMetadata &metadata) { + const ClientBufferHandleMetadata &metadata, + const toolbelt::FileDescriptor &fd) { ShadowEvent event; auto *msg = event.mutable_register_client_buffer(); ToProto(metadata, msg->mutable_metadata()); - SendEvent(event); + std::vector fds; + if (fd.Valid()) { + msg->set_has_fd(true); + msg->set_fd_index(0); + fds.push_back(fd); + } + SendEvent(event, fds); } void ShadowReplicator::SendUnregisterClientBuffer( @@ -281,7 +312,9 @@ ShadowReplicator::ReceiveEvent(std::vector &fds) { } bool has_fds = event.has_create_channel() || event.has_add_publisher() || - event.has_add_subscriber(); + event.has_add_subscriber() || + (event.has_register_client_buffer() && + event.register_client_buffer().has_fd()); if (has_fds) { absl::Status s = socket_.ReceiveFds(fds); if (!s.ok()) { @@ -391,7 +424,13 @@ absl::StatusOr ShadowReplicator::ReceiveStateDump() { if (!ch.ok()) { return ch.status(); } - (*ch)->client_buffers.push_back(std::move(metadata)); + toolbelt::FileDescriptor fd; + if (msg.has_fd() && static_cast(msg.fd_index()) < fds.size()) { + fd = std::move(fds[size_t(msg.fd_index())]); + } + (*ch)->client_buffers.push_back( + RegisteredClientBuffer{.metadata = std::move(metadata), + .fd = std::move(fd)}); continue; } diff --git a/server/shadow_replicator.h b/server/shadow_replicator.h index 1681271..85b94cb 100644 --- a/server/shadow_replicator.h +++ b/server/shadow_replicator.h @@ -66,7 +66,7 @@ struct RecoveredChannel { int max_publishers = 0; toolbelt::FileDescriptor ccb_fd; toolbelt::FileDescriptor bcb_fd; - std::vector client_buffers; + std::vector client_buffers; std::vector publishers; std::vector subscribers; }; @@ -102,7 +102,8 @@ class ShadowReplicator { void SendAddSubscriber(const std::string &channel_name, const SubscriberUser *sub); void SendRemoveSubscriber(const std::string &channel_name, int sub_id); - void SendRegisterClientBuffer(const ClientBufferHandleMetadata &metadata); + void SendRegisterClientBuffer(const ClientBufferHandleMetadata &metadata, + const toolbelt::FileDescriptor &fd = {}); void SendUnregisterClientBuffer(const std::string &channel_name, uint64_t session_id, uint32_t buffer_index); void SendUpdateChannelOptions(const ServerChannel *channel); diff --git a/shadow/shadow.cc b/shadow/shadow.cc index de8617e..96fec12 100644 --- a/shadow/shadow.cc +++ b/shadow/shadow.cc @@ -11,6 +11,38 @@ namespace subspace { namespace { +ClientBufferAllocatorKind FromProtoAllocator(ClientBufferAllocator allocator) { + switch (allocator) { + case CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD: + return ClientBufferAllocatorKind::kAndroidMemfd; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM: + return ClientBufferAllocatorKind::kSplitShm; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK: + return ClientBufferAllocatorKind::kSplitCallback; + case CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST: + return ClientBufferAllocatorKind::kSplitBufferFreeTest; + case CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED: + default: + return ClientBufferAllocatorKind::kUnspecified; + } +} + +ClientBufferAllocator ToProtoAllocator(ClientBufferAllocatorKind allocator) { + switch (allocator) { + case ClientBufferAllocatorKind::kAndroidMemfd: + return CLIENT_BUFFER_ALLOCATOR_ANDROID_MEMFD; + case ClientBufferAllocatorKind::kSplitShm: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_SHM; + case ClientBufferAllocatorKind::kSplitCallback: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_CALLBACK; + case ClientBufferAllocatorKind::kSplitBufferFreeTest: + return CLIENT_BUFFER_ALLOCATOR_SPLIT_BUFFER_FREE_TEST; + case ClientBufferAllocatorKind::kUnspecified: + default: + return CLIENT_BUFFER_ALLOCATOR_UNSPECIFIED; + } +} + ClientBufferHandleMetadata FromProto(const ClientBufferHandleMetadataProto &proto) { ClientBufferHandleMetadata metadata; @@ -24,11 +56,7 @@ FromProto(const ClientBufferHandleMetadataProto &proto) { metadata.handle = static_cast(proto.handle()); metadata.shadow_file = proto.shadow_file(); metadata.object_name = proto.object_name(); - metadata.allocator = proto.allocator(); - metadata.pool_id = proto.pool_id(); - metadata.cache_enabled = proto.cache_enabled(); - metadata.alignment = proto.alignment(); - metadata.allocator_metadata = proto.allocator_metadata(); + metadata.allocator = FromProtoAllocator(proto.allocator()); return metadata; } @@ -44,11 +72,7 @@ void ToProto(const ClientBufferHandleMetadata &metadata, proto->set_handle(static_cast(metadata.handle)); proto->set_shadow_file(metadata.shadow_file); proto->set_object_name(metadata.object_name); - proto->set_allocator(metadata.allocator); - proto->set_pool_id(metadata.pool_id); - proto->set_cache_enabled(metadata.cache_enabled); - proto->set_alignment(metadata.alignment); - *proto->mutable_allocator_metadata() = metadata.allocator_metadata; + proto->set_allocator(ToProtoAllocator(metadata.allocator)); } } // namespace @@ -137,7 +161,9 @@ void Shadow::ClientCoroutine( } bool has_fds = event.has_init() || event.has_create_channel() || - event.has_add_publisher() || event.has_add_subscriber(); + event.has_add_publisher() || event.has_add_subscriber() || + (event.has_register_client_buffer() && + event.register_client_buffer().has_fd()); std::vector fds; if (has_fds) { @@ -181,7 +207,7 @@ absl::Status Shadow::HandleEvent(const ShadowEvent &event, case ShadowEvent::kRemoveSubscriber: return HandleRemoveSubscriber(event.remove_subscriber()); case ShadowEvent::kRegisterClientBuffer: - return HandleRegisterClientBuffer(event.register_client_buffer()); + return HandleRegisterClientBuffer(event.register_client_buffer(), fds); case ShadowEvent::kUnregisterClientBuffer: return HandleUnregisterClientBuffer(event.unregister_client_buffer()); case ShadowEvent::kUpdateChannelOptions: @@ -369,7 +395,8 @@ absl::Status Shadow::HandleRemoveSubscriber(const ShadowRemoveSubscriber &msg) { } absl::Status -Shadow::HandleRegisterClientBuffer(const ShadowRegisterClientBuffer &msg) { +Shadow::HandleRegisterClientBuffer(const ShadowRegisterClientBuffer &msg, + std::vector &fds) { ClientBufferHandleMetadata metadata = FromProto(msg.metadata()); auto it = channels_.find(metadata.channel_name); if (it == channels_.end()) { @@ -378,19 +405,27 @@ Shadow::HandleRegisterClientBuffer(const ShadowRegisterClientBuffer &msg) { metadata.channel_name)); } + toolbelt::FileDescriptor fd; + if (msg.has_fd() && static_cast(msg.fd_index()) < fds.size()) { + fd = std::move(fds[size_t(msg.fd_index())]); + } + auto &buffers = it->second.client_buffers; auto existing = std::find_if(buffers.begin(), buffers.end(), - [&metadata](const ClientBufferHandleMetadata &buffer) { - return buffer.session_id == metadata.session_id && - buffer.buffer_index == metadata.buffer_index && - buffer.slot_id == metadata.slot_id && - buffer.is_prefix == metadata.is_prefix; + [&metadata](const RegisteredClientBuffer &buffer) { + return buffer.metadata.session_id == metadata.session_id && + buffer.metadata.buffer_index == + metadata.buffer_index && + buffer.metadata.slot_id == metadata.slot_id && + buffer.metadata.is_prefix == metadata.is_prefix; }); + RegisteredClientBuffer registered{.metadata = std::move(metadata), + .fd = std::move(fd)}; if (existing != buffers.end()) { - *existing = std::move(metadata); + *existing = std::move(registered); } else { - buffers.push_back(std::move(metadata)); + buffers.push_back(std::move(registered)); } logger_.Log(toolbelt::LogLevel::kDebug, "Shadow: register client buffer '%s' session=%lu buffer=%u " @@ -411,9 +446,10 @@ Shadow::HandleUnregisterClientBuffer(const ShadowUnregisterClientBuffer &msg) { auto &buffers = it->second.client_buffers; buffers.erase( std::remove_if(buffers.begin(), buffers.end(), - [&msg](const ClientBufferHandleMetadata &buffer) { - return buffer.session_id == msg.session_id() && - buffer.buffer_index == msg.buffer_index(); + [&msg](const RegisteredClientBuffer &buffer) { + return buffer.metadata.session_id == msg.session_id() && + buffer.metadata.buffer_index == + msg.buffer_index(); }), buffers.end()); return absl::OkStatus(); @@ -513,11 +549,17 @@ absl::Status Shadow::SendStateDump(toolbelt::UnixSocket &socket) { } // Client-owned split buffers. - for (const ClientBufferHandleMetadata &metadata : ch.client_buffers) { + for (const RegisteredClientBuffer &buffer : ch.client_buffers) { ShadowEvent event; auto *msg = event.mutable_register_client_buffer(); - ToProto(metadata, msg->mutable_metadata()); - if (absl::Status s = SendEvent(socket, event); !s.ok()) { + ToProto(buffer.metadata, msg->mutable_metadata()); + std::vector fds; + if (buffer.fd.Valid()) { + msg->set_has_fd(true); + msg->set_fd_index(0); + fds.push_back(buffer.fd); + } + if (absl::Status s = SendEvent(socket, event, fds); !s.ok()) { return s; } } diff --git a/shadow/shadow.h b/shadow/shadow.h index 9c6536e..09dbb83 100644 --- a/shadow/shadow.h +++ b/shadow/shadow.h @@ -63,7 +63,7 @@ struct ShadowChannel { int max_publishers = 0; toolbelt::FileDescriptor ccb_fd; toolbelt::FileDescriptor bcb_fd; - std::vector client_buffers; + std::vector client_buffers; absl::flat_hash_map publishers; absl::flat_hash_map subscribers; }; @@ -124,7 +124,8 @@ class Shadow { std::vector &fds); absl::Status HandleRemoveSubscriber(const ShadowRemoveSubscriber &msg); absl::Status - HandleRegisterClientBuffer(const ShadowRegisterClientBuffer &msg); + HandleRegisterClientBuffer(const ShadowRegisterClientBuffer &msg, + std::vector &fds); absl::Status HandleUnregisterClientBuffer(const ShadowUnregisterClientBuffer &msg); absl::Status diff --git a/shadow/shadow_test.cc b/shadow/shadow_test.cc index 0471f9b..7bf7ff1 100644 --- a/shadow/shadow_test.cc +++ b/shadow/shadow_test.cc @@ -25,14 +25,22 @@ namespace { using ::absl_testing::IsOk; +static const char *TestTmpDir() { +#if defined(__ANDROID__) + return "/data/local/tmp"; +#else + return "/tmp"; +#endif +} + // Returns a unique-per-process path for a unix socket. mkstemp picks a // unique filename; we close and immediately unlink it (bind requires the // path to not exist) — Shadow::Run / Server then bind a real unix socket // at that path. Using a unique path per process means concurrent or // repeated test invocations don't collide on a fixed /tmp/ path. static std::string MakeUniqueSocketPath(const char *tag) { - std::string templ = - std::string("/tmp/subspace_shadow_test_") + tag + "_XXXXXX"; + std::string templ = std::string(TestTmpDir()) + "/subspace_shadow_test_" + + tag + "_XXXXXX"; std::vector buf(templ.begin(), templ.end()); buf.push_back('\0'); int fd = mkstemp(buf.data()); @@ -361,19 +369,21 @@ TEST_F(ShadowTest, ShadowReceivesRemoveChannel) { TEST_F(ShadowTest, ServerWithoutShadowSocketWorks) { co::CoroutineScheduler sched; - subspace::Server server(sched, "/tmp/subspace_noshadow", "", 0, 0, true, -1, - 1, false, false); + subspace::Server server( + sched, std::string(TestTmpDir()) + "/subspace_noshadow", "", 0, 0, true, + -1, 1, false, false); EXPECT_EQ(server.GetPrimaryShadowReplicator(), nullptr); EXPECT_EQ(server.GetSecondaryShadowReplicator(), nullptr); server.SetShadowSocket(""); EXPECT_EQ(server.GetPrimaryShadowReplicator(), nullptr); - server.SetShadowSocket("/tmp/some_shadow"); + server.SetShadowSocket(std::string(TestTmpDir()) + "/some_shadow"); EXPECT_NE(server.GetPrimaryShadowReplicator(), nullptr); EXPECT_EQ(server.GetSecondaryShadowReplicator(), nullptr); - server.SetShadowSockets("/tmp/primary", "/tmp/secondary"); + server.SetShadowSockets(std::string(TestTmpDir()) + "/primary", + std::string(TestTmpDir()) + "/secondary"); EXPECT_NE(server.GetPrimaryShadowReplicator(), nullptr); EXPECT_NE(server.GetSecondaryShadowReplicator(), nullptr); } @@ -591,7 +601,7 @@ TEST_F(ShadowRecoveryTest, ServerRecoversSplitBufferStateFromShadow) { auto *channel = recovered_channels.at("shadow_split_buffers").get(); ASSERT_TRUE(channel->HasSplitBufferOptions()); EXPECT_TRUE(channel->GetSplitBufferOptions().use_split_buffers); - EXPECT_EQ(channel->ClientBuffers().size(), 5u); + EXPECT_EQ(channel->NumClientBuffers(), 5u); EXPECT_EQ(server_->GetSessionId(), old_session_id); StopServer();