diff --git a/.gitignore b/.gitignore index 4af7fe19..5522cf05 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ vcpkg_installed *.cache* *~ +/dist/ .vscode .trunk setenvs.sh diff --git a/MODERNIZATION.md b/MODERNIZATION.md index 52e3c8c8..33a6da2b 100644 --- a/MODERNIZATION.md +++ b/MODERNIZATION.md @@ -174,31 +174,46 @@ Android NDK r28+. `iostest.sh` green — the compiler's output must stay compatible with the device's fixed libc++ runtime**. -## Phase 1.3 — vcpkg baseline bump + dependency wave (highest-risk phase) -- Bump vcpkg submodule to latest tag; add `"builtin-baseline"` to root - `vcpkg.json` (enables per-port `"overrides"` for pinning/rollback; verify - `merge-dependencies.sh` preserves the key). Document the bump procedure. -- **Overlay ports**: delete `overlayports/magic-enum/` (byte-identical to - upstream) and `overlayports/fmt/` (Phase 1.2 stopgap). Rebuild - `overlayports/folly/` from the new upstream port with **zero patches**, - re-adding only what provably fails. Rebase `overlayports/usrsctp/` and - `overlayports/libdatachannel/` (or drop, if upstream 0.24 works). Drop the - `CMAKE_POLICY_VERSION_MINIMUM` and `VCPKG_OSX_SYSROOT` stopgaps if the new - baseline handles CMake 4 itself. -- **Protobuf 25→33** (major): fix the codegen plugin against new libprotoc - (expect `absl::string_view`/`io::Printer` churn); fix `packages/*/proto.sh` - (hardcoded `arm64-osx` protoc path; drop - `--experimental_allow_proto3_optional`); regenerate + commit all checked-in - generated proto sources. Note abseil static libs now flow into the - XCFramework `libtool` glob — verify symbol completeness in the iOS test - app. -- Fix API churn fallout (boost, libdatachannel 0.24, openssl 3.6). Remove - `-fpermissive` from `packages/streamr-proto-rpc/CMakeLists.txt` (GCC-only - flag; meaningless once all-clang). -- CI cache keys: include the vcpkg submodule SHA (currently keyed only on - `vcpkg.json`, which misses submodule bumps). +## Phase 1.3 — vcpkg baseline bump + dependency wave (PR pending) +Baseline: vcpkg tag **2026.06.24** (`builtin-baseline` now pinned in +`vcpkg.json`; the jq-based merge-dependencies.sh preserves the key — and +because the cache keys hash `vcpkg.json`, baseline bumps bust CI caches +automatically). Port versions: protobuf 6.33.4, folly 2026.02.23, boost +1.91, openssl 3.6.3, libdatachannel 0.24.5, fmt 12.2, secp256k1 0.7.1. +- **All five old overlays deleted**; the CMake-4 stopgaps + (`CMAKE_POLICY_VERSION_MINIMUM`, `VCPKG_OSX_SYSROOT`) removed — the new + vcpkg scripts/ports handle CMake 4 themselves. Three minimal overlays + returned, each with a JUSTIFICATION.md: + - **folly**: missing `` include in `result/rich_error_code.h` + (libc++ 22 hard error), and `-DFOLLY_NO_EXCEPTION_TRACER=ON` — folly + 2026's exception tracer interposes `__cxa_throw` and now activates on + macOS (the 2024 tracer was glibc-only), breaking + `std::current_exception()` process-wide and aborting every coro error + path. Found via minimal repro after 18 error-path tests aborted. + - **secp256k1**: enable the recovery module (upstream default-off; + SigningUtils needs `secp256k1_recovery.h`). The separate + `secp256k1_precomputed` archive no longer exists (merged into the main + lib in 0.7) — its find_library is now optional. + - **usrsctp**: the two pre-2026 iOS patches (no `` / + `` in the iPhoneOS SDK) — verified still required. +- **Protobuf 25→33**: all checked-in generated code regenerated (protoc + 33.4); codegen plugin ported to the `absl::string_view` descriptor API; + `proto.sh` scripts detect the protoc triplet dir and drop the removed + `--experimental_allow_proto3_optional` flag. `DebugString()`-based test + assertions replaced with field comparisons (6.33 prefixes a + `goo.gle/debugproto` marker; the format was never stable). +- **folly 2026 API migration**: the seven `scheduleOn(exec)` call sites → + `co_withExecutor(exec, task)` (deprecated, warnings-as-errors in lint). +- magic-enum 0.9.8 headers moved under `magic_enum/`; libdatachannel 0.24 + target renamed to `LibDataChannel::LibDataChannel`; `protobuf::libprotoc` + removed from library targets (only the host codegen plugin needs it — the + new port doesn't export it for cross triplets); `-fpermissive` removed. +- **Verified**: macOS full build + 307/307 tests + full lint; iOS + cross-build green with XCFramework at `platform=iOS, minos=13.0` and no + post-deployment-target runtime symbols. - **Gate**: build/test green macOS + Linux; regenerated proto diff reviewed; - folly overlay patch count documented (target 0–2). + folly overlay patch count documented (achieved: 1 patch + 1 configure + option). **Lesson from 1.2 (feeds the Part 2 install-flow rework):** switching target triplets (host↔iOS↔Android) in the SAME package build dirs silently produces diff --git a/README.md b/README.md index 20f322b7..baa2564c 100644 --- a/README.md +++ b/README.md @@ -155,7 +155,7 @@ The Streamr Native SDK monorepo has two GIT submodules at its root: #### Configuration files | File | Description | |--------------|-----------------------------------------------------------------------------| -| `.vcpkg.json` | Vcpkg dependencies of the whole monorepo. **This file is automatically generated by the `install.sh` script and should not be edited manually.** | +| `.vcpkg.json` | Vcpkg dependencies of the whole monorepo. **The `dependencies` array is automatically generated by the `install.sh` script and should not be edited manually.** The `builtin-baseline` key pins the vcpkg ports snapshot; to bump it: update the `vcpkg` submodule to the desired release tag, set `builtin-baseline` to that tag's commit SHA, rebuild everything on all platforms, and revisit every directory under `overlayports/` (each documents in its JUSTIFICATION.md why it exists — delete overlays the new baseline obsoletes). | | `.clang-tidy` | Configuration file for the clangd-tidy high-level linter. | | `.clang-format` | Configuration file for the clang-format low-level linter. | | `.clangd` | Configuration file for the clangd plugin of Cursor/VSCode. Controls syntax highlighting, code completion, etc. | diff --git a/install-prerequisities.sh b/install-prerequisities.sh index 70e94cae..6c9d4575 100644 --- a/install-prerequisities.sh +++ b/install-prerequisities.sh @@ -55,7 +55,8 @@ else # between macOS and Linux or the format check flip-flops. sudo apt-get install -y build-essential cmake ninja-build jq \ clang-22 lld-22 clang-tools-22 clangd-22 libc++-22-dev libc++abi-22-dev \ - clang-format-22 + clang-format-22 \ + autoconf autoconf-archive automake libtool sudo rm -f /usr/bin/clang-format sudo rm -f /usr/bin/clangd sudo ln -s /usr/bin/clang-format-22 /usr/bin/clang-format diff --git a/overlayports/README.md b/overlayports/README.md new file mode 100644 index 00000000..fe83662c --- /dev/null +++ b/overlayports/README.md @@ -0,0 +1,11 @@ +# Overlay ports + +Reset at the 2026.06 vcpkg baseline bump: the previous overlays (folly, +usrsctp, libdatachannel, magic-enum, fmt) existed to patch ports at the old +2024 baseline and were all obsoleted by upstream. Each overlay present here +documents its own reason in a JUSTIFICATION.md. + +Policy: add a port here only with a written justification in the port +directory (what fails without it, and the upstream issue/PR if one exists). +Prefer a `"builtin-baseline"`/`"overrides"` pin in `vcpkg.json` for version +problems; overlays are for patches that upstream does not carry. diff --git a/overlayports/fmt/fix-cstdlib-include.patch b/overlayports/fmt/fix-cstdlib-include.patch deleted file mode 100644 index d5da010b..00000000 --- a/overlayports/fmt/fix-cstdlib-include.patch +++ /dev/null @@ -1,15 +0,0 @@ -Add the missing include (malloc/free). fmt defines -_LIBCPP_REMOVE_TRANSITIVE_INCLUDES, and libc++ 22 no longer provides -malloc/free transitively through the other headers. Fixed upstream in -fmt 12; this overlay stays on 11.x because folly 2024.08 still needs -the fmt/core.h -> fmt/format.h shim that fmt 12 removed. ---- a/include/fmt/format.h -+++ b/include/fmt/format.h -@@ -43,6 +43,7 @@ - # include // std::signbit - # include // std::byte - # include // uint32_t -+# include // std::malloc, std::free - # include // std::memcpy - # include // std::numeric_limits - # include // std::bad_alloc diff --git a/overlayports/fmt/portfile.cmake b/overlayports/fmt/portfile.cmake deleted file mode 100644 index e9e2bb67..00000000 --- a/overlayports/fmt/portfile.cmake +++ /dev/null @@ -1,30 +0,0 @@ -vcpkg_from_github( - OUT_SOURCE_PATH SOURCE_PATH - REPO fmtlib/fmt - REF "${VERSION}" - SHA512 46974efd36e613477351aa357c451cee434da797c2a505f9f86d73e394dcb35dc2dc0cda66abb98c023e8f24deac9d8e3ee6f9f6c0971cc4c00e37c34aa7f15f - HEAD_REF master - PATCHES - fix-cstdlib-include.patch -) - -vcpkg_cmake_configure( - SOURCE_PATH "${SOURCE_PATH}" - OPTIONS - -DFMT_CMAKE_DIR=share/fmt - -DFMT_TEST=OFF - -DFMT_DOC=OFF -) - -vcpkg_cmake_install() -vcpkg_cmake_config_fixup() -vcpkg_fixup_pkgconfig() -vcpkg_copy_pdbs() - -file(REMOVE_RECURSE - "${CURRENT_PACKAGES_DIR}/debug/include" - "${CURRENT_PACKAGES_DIR}/debug/share" -) - -file(INSTALL "${CMAKE_CURRENT_LIST_DIR}/usage" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}") -vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/LICENSE") diff --git a/overlayports/fmt/usage b/overlayports/fmt/usage deleted file mode 100644 index e5a9d704..00000000 --- a/overlayports/fmt/usage +++ /dev/null @@ -1,8 +0,0 @@ -The package fmt provides CMake targets: - - find_package(fmt CONFIG REQUIRED) - target_link_libraries(main PRIVATE fmt::fmt) - - # Or use the header-only version - find_package(fmt CONFIG REQUIRED) - target_link_libraries(main PRIVATE fmt::fmt-header-only) diff --git a/overlayports/fmt/vcpkg.json b/overlayports/fmt/vcpkg.json deleted file mode 100644 index 13dc66de..00000000 --- a/overlayports/fmt/vcpkg.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "name": "fmt", - "version": "11.2.0", - "description": "{fmt} is an open-source formatting library providing a fast and safe alternative to C stdio and C++ iostreams.", - "homepage": "https://github.com/fmtlib/fmt", - "license": "MIT", - "dependencies": [ - { - "name": "vcpkg-cmake", - "host": true - }, - { - "name": "vcpkg-cmake-config", - "host": true - } - ] -} diff --git a/overlayports/folly/JUSTIFICATION.md b/overlayports/folly/JUSTIFICATION.md new file mode 100644 index 00000000..f89c551a --- /dev/null +++ b/overlayports/folly/JUSTIFICATION.md @@ -0,0 +1,17 @@ +# Why this overlay exists + +Baseline: vcpkg 2026.06.24 (folly 2026.02.23.00). Identical to the upstream +port except one added patch: + +- `fix-missing-exception-include.patch`: folly/result/rich_error_code.h uses + `std::exception_ptr` without including ``; libc++ 22's strict + transitive includes make this a hard compile error. Remove when a folly + version with the fix reaches the pinned baseline. + +- `-DFOLLY_NO_EXCEPTION_TRACER=ON` (configure option): folly 2026.02's + exception tracer interposes `__cxa_throw` and, unlike in 2024-era folly + (whose tracer was glibc-only and compiled to empty objects on libc++), + activates on macOS — breaking `std::current_exception()` process-wide + (returns null inside catch blocks), which aborts every folly::coro error + path ("Cannot use throw_exception with an empty folly::exception_wrapper"). + Verified with a minimal repro. The SDK does not use the tracer. diff --git a/overlayports/folly/disable-cxa-init-primary-exception.patch b/overlayports/folly/disable-cxa-init-primary-exception.patch deleted file mode 100644 index 19e9cbe9..00000000 --- a/overlayports/folly/disable-cxa-init-primary-exception.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/folly/lang/Exception.cpp b/folly/lang/Exception.cpp -index 2ce0e1f..c391fbc 100644 ---- a/folly/lang/Exception.cpp -+++ b/folly/lang/Exception.cpp -@@ -708,7 +708,7 @@ std::exception_ptr make_exception_ptr_with_( - make_exception_ptr_with_arg_ const& arg, void* func) noexcept { - void* object = abi::__cxa_allocate_exception(arg.size); - auto type = const_cast(arg.type); --#if _LIBCPP_VERSION >= 180000 && _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION -+#if _LIBCPP_VERSION >= 180000 && _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION && 0 - (void)abi::__cxa_init_primary_exception(object, type, arg.dtor); - #else - cxxabi_with_cxa_exception(object, [&](auto exception) { diff --git a/overlayports/folly/disable-groupvarint.patch b/overlayports/folly/disable-groupvarint.patch deleted file mode 100644 index 4d553ff7..00000000 --- a/overlayports/folly/disable-groupvarint.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/folly/GroupVarint.h b/folly/GroupVarint.h -index e364431..c27c2cf 100644 ---- a/folly/GroupVarint.h -+++ b/folly/GroupVarint.h -@@ -33,7 +33,7 @@ - - #if FOLLY_X64 || defined(__i386__) || FOLLY_PPC64 || FOLLY_AARCH64 || \ - FOLLY_RISCV64 --#define FOLLY_HAVE_GROUP_VARINT 1 -+#define FOLLY_HAVE_GROUP_VARINT 0 - #else - #define FOLLY_HAVE_GROUP_VARINT 0 - #endif diff --git a/overlayports/folly/disable-non-underscore-posix-names.patch b/overlayports/folly/disable-non-underscore-posix-names.patch deleted file mode 100644 index ad36fad7..00000000 --- a/overlayports/folly/disable-non-underscore-posix-names.patch +++ /dev/null @@ -1,34 +0,0 @@ -diff --git a/folly/portability/Windows.h b/folly/portability/Windows.h -index 86fd0f9..ccad11e 100644 ---- a/folly/portability/Windows.h -+++ b/folly/portability/Windows.h -@@ -32,24 +32,17 @@ - // disabled to ensure all of the normal names get declared properly. - #include - --#ifndef __STDC__ --/* nolint */ --#define __STDC__ 1 - #pragma push_macro("_CRT_DECLARE_NONSTDC_NAMES") - #ifdef _CRT_DECLARE_NONSTDC_NAMES - #undef _CRT_DECLARE_NONSTDC_NAMES - #endif -+ -+#include - #pragma push_macro("_CRT_INTERNAL_NONSTDC_NAMES") --#undef _CRT_INTERNAL_NONSTDC_NAMES --#include // @manual nolint --#include // @manual nolint --#undef __STDC__ -+#define _CRT_INTERNAL_NONSTDC_NAMES 0 -+#include -+#include - #pragma pop_macro("_CRT_INTERNAL_NONSTDC_NAMES") --#pragma pop_macro("_CRT_DECLARE_NONSTDC_NAMES") --#else --#include // @manual nolint --#include // @manual nolint --#endif - - #if defined(min) || defined(max) - #error Windows.h needs to be included by this header, or else NOMINMAX needs \ diff --git a/overlayports/folly/fix-android-remainder.patch b/overlayports/folly/fix-android-remainder.patch deleted file mode 100644 index de9c6d5b..00000000 --- a/overlayports/folly/fix-android-remainder.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/folly/portability/Math.h b/folly/portability/Math.h -index 594bab8..53b8e9e 100644 ---- a/folly/portability/Math.h -+++ b/folly/portability/Math.h -@@ -20,7 +20,7 @@ - - namespace folly { - --#if !defined(__ANDROID__) && !defined(__UCLIBC__) -+#if !(defined(__ANDROID__) && defined(__UCLIBC__)) - - /** - * Most platforms hopefully provide std::nextafter, std::remainder. diff --git a/overlayports/folly/fix-cursor.patch b/overlayports/folly/fix-cursor.patch deleted file mode 100644 index 64724f2a..00000000 --- a/overlayports/folly/fix-cursor.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/folly/io/Cursor.h b/folly/io/Cursor.h -index 7a0abc9..710ba3e 100644 ---- a/folly/io/Cursor.h -+++ b/folly/io/Cursor.h -@@ -683,7 +683,7 @@ class CursorBase { - * - * @methodset Accessors - */ -- std::basic_string_view peekView() { -+ std::basic_string_view peekView() { - auto bytes = peekBytes(); - return {bytes.data(), bytes.size()}; - } diff --git a/overlayports/folly/fix-deps.patch b/overlayports/folly/fix-deps.patch index 14e7991b..500b3a71 100644 --- a/overlayports/folly/fix-deps.patch +++ b/overlayports/folly/fix-deps.patch @@ -1,220 +1,239 @@ diff --git a/CMake/folly-config.cmake.in b/CMake/folly-config.cmake.in -index 0b96f0a10..1559f9f70 100644 +index 5fc83ac..7efb0fc 100644 --- a/CMake/folly-config.cmake.in +++ b/CMake/folly-config.cmake.in -@@ -29,10 +29,30 @@ endif() +@@ -34,10 +34,31 @@ endif() set(FOLLY_LIBRARIES Folly::folly) # Find folly's dependencies -find_dependency(fmt) +find_dependency(fmt CONFIG) +find_dependency(double-conversion CONFIG) -+find_dependency(glog CONFIG) ++find_dependency(FastFloat CONFIG) ++set(z_vcpkg_folly_gflags_backup ${GFLAGS_USE_TARGET_NAMESPACE}) ++set(GFLAGS_USE_TARGET_NAMESPACE ON) +find_dependency(gflags CONFIG) ++set(GFLAGS_USE_TARGET_NAMESPACE ${z_vcpkg_folly_gflags_backup}) ++find_dependency(glog CONFIG) +find_dependency(Libevent CONFIG) -+if (NOT @CMAKE_DISABLE_FIND_PACKAGE_Zstd@) -+ find_dependency(zstd CONFIG) ++find_dependency(ZLIB) ++if("@VCPKG_LOCK_FIND_PACKAGE_LZ4@") ++ find_dependency(lz4 CONFIG) +endif() -+if (@CMAKE_REQUIRE_FIND_PACKAGE_ZLIB@) -+ find_dependency(ZLIB MODULE) ++if("@VCPKG_LOCK_FIND_PACKAGE_ZSTD@") ++ find_dependency(zstd CONFIG) +endif() -+find_dependency(OpenSSL MODULE) -+if (NOT @CMAKE_DISABLE_FIND_PACKAGE_unofficial-sodium@) -+ find_dependency(unofficial-sodium CONFIG) ++if("@VCPKG_LOCK_FIND_PACKAGE_SNAPPY@") ++ find_dependency(Snappy CONFIG) +endif() -+if (NOT @CMAKE_DISABLE_FIND_PACKAGE_Snappy@) -+ find_dependency(Snappy CONFIG) -+endif() -+if (NOT @CMAKE_DISABLE_FIND_PACKAGE_LZ4@) -+ find_dependency(lz4 CONFIG) ++if("@VCPKG_LOCK_FIND_PACKAGE_LIBSODIUM@") ++ find_dependency(unofficial-sodium CONFIG) +endif() set(Boost_USE_STATIC_LIBS "@FOLLY_BOOST_LINK_STATIC@") --find_dependency(Boost 1.51.0 MODULE -+find_dependency(Boost +-find_package(Boost 1.69.0 REQUIRED ++find_dependency(Boost 1.69.0 COMPONENTS context filesystem +diff --git a/CMake/folly-config.h.cmake b/CMake/folly-config.h.cmake +index 1da1cc1..701ec99 100644 +--- a/CMake/folly-config.h.cmake ++++ b/CMake/folly-config.h.cmake +@@ -16,6 +16,9 @@ + + #pragma once + ++#cmakedefine01 FOLLY_HAS_LIBURING ++#cmakedefine01 FOLLY_HAS_LIBAIO ++ + #ifdef __APPLE__ + #include // @manual + #endif diff --git a/CMake/folly-deps.cmake b/CMake/folly-deps.cmake -index 41a513a30..32c8826ae 100644 +index 1c41750..6ab485c 100644 --- a/CMake/folly-deps.cmake +++ b/CMake/folly-deps.cmake -@@ -35,7 +35,7 @@ else() - endif() - set(Boost_USE_STATIC_LIBS "${FOLLY_BOOST_LINK_STATIC}") +@@ -57,14 +57,17 @@ find_package(Boost 1.69.0 REQUIRED + # Per-target Boost dependencies are specified via EXTERNAL_DEPS + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${Boost_INCLUDE_DIRS}) --find_package(Boost 1.51.0 MODULE -+find_package(Boost - COMPONENTS - context - filesystem -@@ -45,37 +45,37 @@ find_package(Boost 1.51.0 MODULE - thread - REQUIRED - ) -+set(Boost_LIBRARIES Boost::boost Boost::context Boost::filesystem Boost::program_options Boost::regex Boost::system Boost::thread) - list(APPEND FOLLY_LINK_LIBRARIES ${Boost_LIBRARIES}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${Boost_INCLUDE_DIRS}) -- -find_package(DoubleConversion MODULE REQUIRED) --list(APPEND FOLLY_LINK_LIBRARIES ${DOUBLE_CONVERSION_LIBRARY}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${DOUBLE_CONVERSION_INCLUDE_DIR}) -- ++find_package(double-conversion CONFIG REQUIRED) ++set(DOUBLE_CONVERSION_LIBRARY double-conversion::double-conversion) + list(APPEND FOLLY_LINK_LIBRARIES ${DOUBLE_CONVERSION_LIBRARY}) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${DOUBLE_CONVERSION_INCLUDE_DIR}) + +-find_package(FastFloat MODULE REQUIRED) +-list(APPEND FOLLY_INCLUDE_DIRECTORIES ${FASTFLOAT_INCLUDE_DIR}) ++find_package(FastFloat CONFIG REQUIRED) ++list(APPEND FOLLY_LINK_LIBRARIES FastFloat::fast_float) + -find_package(Gflags MODULE) --set(FOLLY_HAVE_LIBGFLAGS ${LIBGFLAGS_FOUND}) --if(LIBGFLAGS_FOUND) -- list(APPEND FOLLY_LINK_LIBRARIES ${LIBGFLAGS_LIBRARY}) -- list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBGFLAGS_INCLUDE_DIR}) -- set(FOLLY_LIBGFLAGS_LIBRARY ${LIBGFLAGS_LIBRARY}) -- set(FOLLY_LIBGFLAGS_INCLUDE ${LIBGFLAGS_INCLUDE_DIR}) --endif() ++set(GFLAGS_USE_TARGET_NAMESPACE ON) ++find_package(LIBGFLAGS NAMES gflags REQUIRED) ++set(LIBGFLAGS_LIBRARY gflags::gflags) + set(FOLLY_HAVE_LIBGFLAGS ${LIBGFLAGS_FOUND}) + if(LIBGFLAGS_FOUND) + list(APPEND FOLLY_LINK_LIBRARIES ${LIBGFLAGS_LIBRARY}) +@@ -73,7 +76,8 @@ if(LIBGFLAGS_FOUND) + set(FOLLY_LIBGFLAGS_INCLUDE ${LIBGFLAGS_INCLUDE_DIR}) + endif() -find_package(Glog MODULE) --set(FOLLY_HAVE_LIBGLOG ${GLOG_FOUND}) --list(APPEND FOLLY_LINK_LIBRARIES ${GLOG_LIBRARY}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${GLOG_INCLUDE_DIR}) -+find_package(double-conversion CONFIG REQUIRED) -+list(APPEND FOLLY_LINK_LIBRARIES double-conversion::double-conversion) ++find_package(GLOG NAMES glog REQUIRED) ++set(GLOG_LIBRARY glog::glog) + set(FOLLY_HAVE_LIBGLOG ${GLOG_FOUND}) + list(APPEND FOLLY_LINK_LIBRARIES glog::glog) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${GLOG_INCLUDE_DIR}) +@@ -83,11 +87,16 @@ if (EXISTS "${GLOG_INCLUDE_DIR}/glog/export.h") + list(APPEND FOLLY_CXX_FLAGS -DGLOG_USE_GLOG_EXPORT) + endif() -find_package(LibEvent MODULE REQUIRED) --list(APPEND FOLLY_LINK_LIBRARIES ${LIBEVENT_LIB}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBEVENT_INCLUDE_DIR}) -+find_package(glog CONFIG REQUIRED) -+set(FOLLY_HAVE_LIBGLOG 1) -+list(APPEND FOLLY_LINK_LIBRARIES glog::glog) - --find_package(ZLIB MODULE) --set(FOLLY_HAVE_LIBZ ${ZLIB_FOUND}) --if (ZLIB_FOUND) -- list(APPEND FOLLY_INCLUDE_DIRECTORIES ${ZLIB_INCLUDE_DIRS}) -- list(APPEND FOLLY_LINK_LIBRARIES ${ZLIB_LIBRARIES}) -- list(APPEND CMAKE_REQUIRED_LIBRARIES ${ZLIB_LIBRARIES}) -+find_package(gflags CONFIG) -+if(TARGET gflags::gflags) -+ set(FOLLY_HAVE_LIBGFLAGS 1) -+ list(APPEND FOLLY_LINK_LIBRARIES gflags::gflags) -+ set(FOLLY_LIBGFLAGS_LIBRARY gflags::gflags) -+endif() -+ -+find_package(Libevent CONFIG REQUIRED) -+list(APPEND FOLLY_LINK_LIBRARIES libevent::core libevent::extra) ++find_package(LIBEVENT NAMES Libevent REQUIRED) ++set(LIBEVENT_LIB libevent::core libevent::extra) +if(NOT WIN32) -+ list(APPEND FOLLY_LINK_LIBRARIES libevent::pthreads) ++ list(APPEND LIBEVENT_LIB libevent::pthreads) +endif() -+ -+if (CMAKE_REQUIRE_FIND_PACKAGE_ZLIB) -+ find_package(ZLIB MODULE REQUIRED) -+ set(FOLLY_HAVE_LIBZ ${ZLIB_FOUND}) -+ if (ZLIB_FOUND) -+ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${ZLIB_INCLUDE_DIRS}) -+ list(APPEND FOLLY_LINK_LIBRARIES ${ZLIB_LIBRARIES}) -+ list(APPEND CMAKE_REQUIRED_LIBRARIES ${ZLIB_LIBRARIES}) -+ endif() - endif() - - find_package(OpenSSL 1.1.1 MODULE REQUIRED) -@@ -103,25 +103,29 @@ if (LIBLZMA_FOUND) + list(APPEND FOLLY_LINK_LIBRARIES ${LIBEVENT_LIB}) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBEVENT_INCLUDE_DIR}) + + find_package(ZLIB MODULE) ++set(ZLIB_LIBRARIES ZLIB::ZLIB) # consistent with proxygen + set(FOLLY_HAVE_LIBZ ${ZLIB_FOUND}) + if (ZLIB_FOUND) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${ZLIB_INCLUDE_DIRS}) +@@ -120,21 +129,24 @@ if (LIBLZMA_FOUND) list(APPEND FOLLY_LINK_LIBRARIES ${LIBLZMA_LIBRARIES}) endif() -find_package(LZ4 MODULE) --set(FOLLY_HAVE_LIBLZ4 ${LZ4_FOUND}) --if (LZ4_FOUND) -- list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LZ4_INCLUDE_DIR}) -- list(APPEND FOLLY_LINK_LIBRARIES ${LZ4_LIBRARY}) -+if(NOT CMAKE_DISABLE_FIND_PACKAGE_LZ4) -+ find_package(lz4 CONFIG) -+ if(TARGET lz4::lz4) -+ list(APPEND FOLLY_LINK_LIBRARIES lz4::lz4) -+ endif() ++find_package(LZ4 NAMES lz4) ++set(LZ4_LIBRARY lz4::lz4) + set(FOLLY_HAVE_LIBLZ4 ${LZ4_FOUND}) + if (LZ4_FOUND) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LZ4_INCLUDE_DIR}) + list(APPEND FOLLY_LINK_LIBRARIES ${LZ4_LIBRARY}) endif() -find_package(Zstd MODULE) --set(FOLLY_HAVE_LIBZSTD ${ZSTD_FOUND}) --if(ZSTD_FOUND) -- list(APPEND FOLLY_INCLUDE_DIRECTORIES ${ZSTD_INCLUDE_DIR}) -- list(APPEND FOLLY_LINK_LIBRARIES ${ZSTD_LIBRARY}) -+if(NOT CMAKE_DISABLE_FIND_PACKAGE_Zstd) -+ find_package(zstd CONFIG) -+ if(TARGET zstd::libzstd_shared ) -+ set(FOLLY_HAVE_LIBZSTD 1) -+ list(APPEND FOLLY_LINK_LIBRARIES zstd::libzstd_shared) -+ elseif( TARGET zstd::libzstd_static ) -+ set(FOLLY_HAVE_LIBZSTD 1) -+ list(APPEND FOLLY_LINK_LIBRARIES zstd::libzstd_static) -+ endif() ++find_package(ZSTD NAMES zstd) ++set(ZSTD_LIBRARY zstd::libzstd) + set(FOLLY_HAVE_LIBZSTD ${ZSTD_FOUND}) + if(ZSTD_FOUND) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${ZSTD_INCLUDE_DIR}) + list(APPEND FOLLY_LINK_LIBRARIES ${ZSTD_LIBRARY}) endif() -find_package(Snappy MODULE) --set(FOLLY_HAVE_LIBSNAPPY ${SNAPPY_FOUND}) --if (SNAPPY_FOUND) -- list(APPEND FOLLY_INCLUDE_DIRECTORIES ${SNAPPY_INCLUDE_DIR}) -- list(APPEND FOLLY_LINK_LIBRARIES ${SNAPPY_LIBRARY}) -+if(NOT CMAKE_DISABLE_FIND_PACKAGE_Snappy) -+ find_package(Snappy CONFIG) -+ if(TARGET Snappy::snappy) -+ list(APPEND FOLLY_LINK_LIBRARIES Snappy::snappy) -+ endif() - endif() - - find_package(LibDwarf) -@@ -132,17 +136,24 @@ find_package(Libiberty) - list(APPEND FOLLY_LINK_LIBRARIES ${LIBIBERTY_LIBRARIES}) ++find_package(SNAPPY NAMES Snappy) ++set(SNAPPY_LIBRARY Snappy::snappy) + set(FOLLY_HAVE_LIBSNAPPY ${SNAPPY_FOUND}) + if (SNAPPY_FOUND) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${SNAPPY_INCLUDE_DIR}) +@@ -150,14 +162,19 @@ list(APPEND FOLLY_LINK_LIBRARIES ${LIBIBERTY_LIBRARIES}) list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBIBERTY_INCLUDE_DIRS}) --find_package(LibAIO) --list(APPEND FOLLY_LINK_LIBRARIES ${LIBAIO_LIBRARIES}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBAIO_INCLUDE_DIRS}) -+if(WITH_libaio) -+ find_package(LibAIO) -+ list(APPEND FOLLY_LINK_LIBRARIES ${LIBAIO_LIBRARIES}) -+ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBAIO_INCLUDE_DIRS}) -+endif() + find_package(LibAIO) ++set(FOLLY_HAS_LIBAIO ${VCPKG_LOCK_FIND_PACKAGE_LibAIO}) + list(APPEND FOLLY_LINK_LIBRARIES ${LIBAIO_LIBRARIES}) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBAIO_INCLUDE_DIRS}) --find_package(LibUring) --list(APPEND FOLLY_LINK_LIBRARIES ${LIBURING_LIBRARIES}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBURING_INCLUDE_DIRS}) -+if(WITH_liburing) -+ find_package(LibUring) -+ list(APPEND FOLLY_LINK_LIBRARIES ${LIBURING_LIBRARIES}) -+ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBURING_INCLUDE_DIRS}) -+endif() + find_package(LibUring) ++set(FOLLY_HAS_LIBURING ${VCPKG_LOCK_FIND_LibUring}) + list(APPEND FOLLY_LINK_LIBRARIES ${LIBURING_LIBRARIES}) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBURING_INCLUDE_DIRS}) -find_package(Libsodium) --list(APPEND FOLLY_LINK_LIBRARIES ${LIBSODIUM_LIBRARIES}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBSODIUM_INCLUDE_DIRS}) -+if(NOT CMAKE_DISABLE_FIND_PACKAGE_unofficial-sodium) -+ find_package(unofficial-sodium CONFIG) -+ if(TARGET unofficial-sodium::sodium) -+ list(APPEND FOLLY_LINK_LIBRARIES unofficial-sodium::sodium) -+ endif() ++find_package(LIBSODIUM NAMES unofficial-sodium) ++if(LIBSODIUM_FOUND) ++ set(LIBSODIUM_LIBRARIES unofficial-sodium::sodium) +endif() + list(APPEND FOLLY_LINK_LIBRARIES ${LIBSODIUM_LIBRARIES}) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBSODIUM_INCLUDE_DIRS}) - list(APPEND FOLLY_LINK_LIBRARIES ${CMAKE_DL_LIBS}) - list(APPEND CMAKE_REQUIRED_LIBRARIES ${CMAKE_DL_LIBS}) -@@ -153,10 +164,10 @@ if (PYTHON_EXTENSIONS) - endif () - - find_package(LibUnwind) --list(APPEND FOLLY_LINK_LIBRARIES ${LIBUNWIND_LIBRARIES}) --list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBUNWIND_INCLUDE_DIRS}) +@@ -174,6 +191,8 @@ list(APPEND FOLLY_LINK_LIBRARIES ${LIBUNWIND_LIBRARIES}) + list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBUNWIND_INCLUDE_DIRS}) if (LIBUNWIND_FOUND) set(FOLLY_HAVE_LIBUNWIND ON) -+ list(APPEND FOLLY_LINK_LIBRARIES ${LIBUNWIND_LIBRARIES}) -+ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${LIBUNWIND_INCLUDE_DIRS}) ++ list(REMOVE_ITEM FOLLY_LINK_LIBRARIES ${LIBLZMA_LIBRARIES}) ++ list(APPEND FOLLY_LINK_LIBRARIES ${LIBLZMA_LIBRARIES}) endif() if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD") list(APPEND FOLLY_LINK_LIBRARIES "execinfo") -@@ -298,11 +309,7 @@ endif() - - add_library(folly_deps INTERFACE) - --find_package(fmt CONFIG) --if (NOT DEFINED fmt_CONFIG) -- # Fallback on a normal search on the current system -- find_package(Fmt MODULE REQUIRED) --endif() -+find_package(fmt CONFIG REQUIRED) - target_link_libraries(folly_deps INTERFACE fmt::fmt) +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 49dd964..b84f338 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -273,7 +273,8 @@ folly_resolve_deferred_dependencies() + # This points to the SSL test certificates used by TestSSLServer and related tests + if(TARGET folly_testing_test_util) + target_compile_definitions(folly_testing_test_util INTERFACE +- FOLLY_CERTS_DIR="${FOLLY_DIR}/io/async/test/certs" ++ $ ++ $ + ) + endif() - list(REMOVE_DUPLICATES FOLLY_INCLUDE_DIRECTORIES) +@@ -285,7 +286,8 @@ add_library(folly_test_util + ${FOLLY_DIR}/json/JsonTestUtil.cpp + ) + target_compile_definitions(folly_test_util PUBLIC +- FOLLY_CERTS_DIR="${FOLLY_DIR}/io/async/test/certs" ++ $ ++ $ + ) + set_property(TARGET folly_test_util PROPERTY VERSION ${PACKAGE_VERSION}) + target_link_libraries(folly_test_util +diff --git a/folly/io/async/AsyncIO.cpp b/folly/io/async/AsyncIO.cpp +index 2760e0f..a51c16c 100644 +--- a/folly/io/async/AsyncIO.cpp ++++ b/folly/io/async/AsyncIO.cpp +@@ -35,7 +35,7 @@ + #include + #endif + +-#if __has_include() ++#if FOLLY_HAS_LIBAIO + + // debugging helpers + namespace { +diff --git a/folly/io/async/AsyncIO.h b/folly/io/async/AsyncIO.h +index 36c6df2..02ff518 100644 +--- a/folly/io/async/AsyncIO.h ++++ b/folly/io/async/AsyncIO.h +@@ -18,7 +18,7 @@ + + #include + +-#if __has_include() ++#if FOLLY_HAS_LIBAIO + + #include + +diff --git a/folly/io/async/Liburing.h b/folly/io/async/Liburing.h +index 8e81aaa..c7f4a67 100644 +--- a/folly/io/async/Liburing.h ++++ b/folly/io/async/Liburing.h +@@ -17,7 +17,5 @@ + #pragma once + + #if defined(__linux__) && __has_include() +-#define FOLLY_HAS_LIBURING 1 + #else +-#define FOLLY_HAS_LIBURING 0 + #endif +diff --git a/folly/io/async/SimpleAsyncIO.cpp b/folly/io/async/SimpleAsyncIO.cpp +index cceb964..9f97e36 100644 +--- a/folly/io/async/SimpleAsyncIO.cpp ++++ b/folly/io/async/SimpleAsyncIO.cpp +@@ -25,7 +25,7 @@ + + namespace folly { + +-#if __has_include() ++#if FOLLY_HAS_LIBAIO + static constexpr bool has_aio = true; + using aio_type = AsyncIO; + #else diff --git a/overlayports/folly/fix-fmt-header.patch b/overlayports/folly/fix-fmt-header.patch new file mode 100644 index 00000000..81596623 --- /dev/null +++ b/overlayports/folly/fix-fmt-header.patch @@ -0,0 +1,480 @@ +diff --git a/folly/Format.h b/folly/Format.h +index 23837cff1..e13beda1d 100644 +--- a/folly/Format.h ++++ b/folly/Format.h +@@ -20,7 +20,7 @@ + + /** + * folly::format has been superseded by +- * [fmt](https://fmt.dev/latest/index.html). `#include ` ++ * [fmt](https://fmt.dev/latest/index.html). `#include ` + * + * format() performs text-formatting, similar to Python's str.format. The full + * specification is on github: +diff --git a/folly/IPAddress.cpp b/folly/IPAddress.cpp +index 678412283..c4fa32589 100644 +--- a/folly/IPAddress.cpp ++++ b/folly/IPAddress.cpp +@@ -21,7 +21,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/IPAddressV4.cpp b/folly/IPAddressV4.cpp +index 173f39a4e..a214c6064 100644 +--- a/folly/IPAddressV4.cpp ++++ b/folly/IPAddressV4.cpp +@@ -19,7 +19,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/IPAddressV6.cpp b/folly/IPAddressV6.cpp +index 22771031a..ec49c54ea 100644 +--- a/folly/IPAddressV6.cpp ++++ b/folly/IPAddressV6.cpp +@@ -20,7 +20,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/SocketAddress.cpp b/folly/SocketAddress.cpp +index 74ef1792a..dd5974074 100644 +--- a/folly/SocketAddress.cpp ++++ b/folly/SocketAddress.cpp +@@ -31,7 +31,7 @@ + + #include + +-#include ++#include + + #include + #include +diff --git a/folly/algorithm/simd/test/FindFixedBenchmark.cpp b/folly/algorithm/simd/test/FindFixedBenchmark.cpp +index 3800795fa..2d40ed816 100644 +--- a/folly/algorithm/simd/test/FindFixedBenchmark.cpp ++++ b/folly/algorithm/simd/test/FindFixedBenchmark.cpp +@@ -19,7 +19,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/algorithm/simd/test/FindFixedTest.cpp b/folly/algorithm/simd/test/FindFixedTest.cpp +index 7628051ef..d9cb784f5 100644 +--- a/folly/algorithm/simd/test/FindFixedTest.cpp ++++ b/folly/algorithm/simd/test/FindFixedTest.cpp +@@ -20,7 +20,7 @@ + + #include + +-#include ++#include + #include + + #include +diff --git a/folly/cli/Args.cpp b/folly/cli/Args.cpp +index 669d120cd..5f3b01eb7 100644 +--- a/folly/cli/Args.cpp ++++ b/folly/cli/Args.cpp +@@ -24,7 +24,7 @@ + #include + #include + +-#include ++#include + + #include + +diff --git a/folly/concurrency/CacheLocality.cpp b/folly/concurrency/CacheLocality.cpp +index 7f6b8adc1..8f5bc7ed1 100644 +--- a/folly/concurrency/CacheLocality.cpp ++++ b/folly/concurrency/CacheLocality.cpp +@@ -29,7 +29,7 @@ + #include + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/container/test/F14InterprocessTest.cpp b/folly/container/test/F14InterprocessTest.cpp +index 93a457558..65213d904 100644 +--- a/folly/container/test/F14InterprocessTest.cpp ++++ b/folly/container/test/F14InterprocessTest.cpp +@@ -24,7 +24,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/container/test/SparseByteSetBenchmark.cpp b/folly/container/test/SparseByteSetBenchmark.cpp +index b5ab4e6b3..85603abb3 100644 +--- a/folly/container/test/SparseByteSetBenchmark.cpp ++++ b/folly/container/test/SparseByteSetBenchmark.cpp +@@ -24,7 +24,7 @@ + #include + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/detail/IPAddressSource.h b/folly/detail/IPAddressSource.h +index fc20cf2a2..389b9fa33 100644 +--- a/folly/detail/IPAddressSource.h ++++ b/folly/detail/IPAddressSource.h +@@ -26,7 +26,7 @@ + + #include + +-#include ++#include + #include + + // BSDish platforms don't provide standard access to s6_addr16 +diff --git a/folly/executors/test/IOThreadPoolDeadlockDetectorObserverTest.cpp b/folly/executors/test/IOThreadPoolDeadlockDetectorObserverTest.cpp +index f09081260..2b36463b5 100644 +--- a/folly/executors/test/IOThreadPoolDeadlockDetectorObserverTest.cpp ++++ b/folly/executors/test/IOThreadPoolDeadlockDetectorObserverTest.cpp +@@ -16,7 +16,7 @@ + + #include + +-#include ++#include + + #include + #include +diff --git a/folly/fibers/detail/AtomicBatchDispatcher.cpp b/folly/fibers/detail/AtomicBatchDispatcher.cpp +index cc93904f2..9a6783fc0 100644 +--- a/folly/fibers/detail/AtomicBatchDispatcher.cpp ++++ b/folly/fibers/detail/AtomicBatchDispatcher.cpp +@@ -18,7 +18,7 @@ + + #include + +-#include ++#include + + namespace folly { + namespace fibers { +diff --git a/folly/futures/detail/Core.cpp b/folly/futures/detail/Core.cpp +index 776614c23..bba1f0465 100644 +--- a/folly/futures/detail/Core.cpp ++++ b/folly/futures/detail/Core.cpp +@@ -18,7 +18,7 @@ + + #include + +-#include ++#include + #include + #include + +diff --git a/folly/hash/test/HashBenchmark.cpp b/folly/hash/test/HashBenchmark.cpp +index 15ac43ddb..2128577c3 100644 +--- a/folly/hash/test/HashBenchmark.cpp ++++ b/folly/hash/test/HashBenchmark.cpp +@@ -25,7 +25,7 @@ + #include + #include + +-#include ++#include + #include + + #include +diff --git a/folly/io/async/fdsock/AsyncFdSocket.cpp b/folly/io/async/fdsock/AsyncFdSocket.cpp +index 23841cdd3..3b332241d 100644 +--- a/folly/io/async/fdsock/AsyncFdSocket.cpp ++++ b/folly/io/async/fdsock/AsyncFdSocket.cpp +@@ -15,7 +15,7 @@ + */ + + #include +-#include ++#include + + #include "AsyncFdSocket.h" + +diff --git a/folly/io/test/FsUtilTest.cpp b/folly/io/test/FsUtilTest.cpp +index 204e539fb..b91891b45 100644 +--- a/folly/io/test/FsUtilTest.cpp ++++ b/folly/io/test/FsUtilTest.cpp +@@ -20,7 +20,7 @@ + #include + #include + +-#include ++#include + #include + + #include +diff --git a/folly/io/tool/HugePageUtil.cpp b/folly/io/tool/HugePageUtil.cpp +index 1bea8c66b..ad5cfefbe 100644 +--- a/folly/io/tool/HugePageUtil.cpp ++++ b/folly/io/tool/HugePageUtil.cpp +@@ -18,7 +18,7 @@ + + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/lang/Exception.h b/folly/lang/Exception.h +index f8e292d7d..8c5d5ef1d 100644 +--- a/folly/lang/Exception.h ++++ b/folly/lang/Exception.h +@@ -17,6 +17,7 @@ + #pragma once + + #include ++#include + #include + #include + #include +diff --git a/folly/lang/test/BitsTest.cpp b/folly/lang/test/BitsTest.cpp +index 176c3e37d..c38415e90 100644 +--- a/folly/lang/test/BitsTest.cpp ++++ b/folly/lang/test/BitsTest.cpp +@@ -20,7 +20,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/logging/LogStreamProcessor.h b/folly/logging/LogStreamProcessor.h +index c60a3ff33..f6b0b8032 100644 +--- a/folly/logging/LogStreamProcessor.h ++++ b/folly/logging/LogStreamProcessor.h +@@ -18,7 +18,7 @@ + + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/observer/WithJitter-inl.h b/folly/observer/WithJitter-inl.h +index 93d720a8c..9e01f955b 100644 +--- a/folly/observer/WithJitter-inl.h ++++ b/folly/observer/WithJitter-inl.h +@@ -22,7 +22,7 @@ + #include + + #include +-#include ++#include + #include + + #include +diff --git a/folly/python/import.h b/folly/python/import.h +index e255d373b..3c0ec63cb 100644 +--- a/folly/python/import.h ++++ b/folly/python/import.h +@@ -18,7 +18,7 @@ + + #include + +-#include ++#include + + #include + #include +diff --git a/folly/result/demo/basketball.cpp b/folly/result/demo/basketball.cpp +index 40a19459c..ef196c814 100644 +--- a/folly/result/demo/basketball.cpp ++++ b/folly/result/demo/basketball.cpp +@@ -14,7 +14,7 @@ + * limitations under the License. + */ + +-#include ++#include + #include // FOLLY_HAS_RESULT + #include + #include +diff --git a/folly/result/rich_error_base.h b/folly/result/rich_error_base.h +index fe2650d13..82132f622 100644 +--- a/folly/result/rich_error_base.h ++++ b/folly/result/rich_error_base.h +@@ -27,7 +27,7 @@ + + #include + #include +-#include ++#include + + // Old `fmt` isn't actually supported, but ... it needs to build :( + #if FMT_VERSION < 80000 +diff --git a/folly/result/rich_error_code.h b/folly/result/rich_error_code.h +index b47556860..79075852d 100644 +--- a/folly/result/rich_error_code.h ++++ b/folly/result/rich_error_code.h +@@ -17,7 +17,7 @@ + #pragma once + + #include +-#include ++#include + + #include + #include +diff --git a/folly/result/test/rich_error_code_test.cpp b/folly/result/test/rich_error_code_test.cpp +index 0f18faf1f..2ce09a292 100644 +--- a/folly/result/test/rich_error_code_test.cpp ++++ b/folly/result/test/rich_error_code_test.cpp +@@ -20,7 +20,7 @@ + #include + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/result/test/rich_error_codes.h b/folly/result/test/rich_error_codes.h +index 598d28170..8b7d0eace 100644 +--- a/folly/result/test/rich_error_codes.h ++++ b/folly/result/test/rich_error_codes.h +@@ -19,7 +19,7 @@ + #include + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/settings/CommandLineParser.cpp b/folly/settings/CommandLineParser.cpp +index bce3dcbaf..4868107f9 100644 +--- a/folly/settings/CommandLineParser.cpp ++++ b/folly/settings/CommandLineParser.cpp +@@ -21,7 +21,7 @@ + #include + #include + +-#include ++#include + #include + #include + #include +diff --git a/folly/synchronization/test/SmallLocksBenchmark.cpp b/folly/synchronization/test/SmallLocksBenchmark.cpp +index 7fe37be22..7302046ae 100644 +--- a/folly/synchronization/test/SmallLocksBenchmark.cpp ++++ b/folly/synchronization/test/SmallLocksBenchmark.cpp +@@ -23,7 +23,7 @@ + #include + #include + +-#include ++#include + + #include + #include +diff --git a/folly/system/MemoryMapping.cpp b/folly/system/MemoryMapping.cpp +index 736bab169..9b6af9308 100644 +--- a/folly/system/MemoryMapping.cpp ++++ b/folly/system/MemoryMapping.cpp +@@ -24,7 +24,7 @@ + #include + #include + +-#include ++#include + #include + + #include +diff --git a/folly/test/FileTest.cpp b/folly/test/FileTest.cpp +index d3a2e5488..e537869b8 100644 +--- a/folly/test/FileTest.cpp ++++ b/folly/test/FileTest.cpp +@@ -19,7 +19,7 @@ + #include + #include + +-#include ++#include + #include + + #include +diff --git a/folly/test/IPAddressBenchmark.cpp b/folly/test/IPAddressBenchmark.cpp +index d5023c3c6..cd43e8464 100644 +--- a/folly/test/IPAddressBenchmark.cpp ++++ b/folly/test/IPAddressBenchmark.cpp +@@ -16,7 +16,7 @@ + + #include + +-#include ++#include + #include + + #include +diff --git a/folly/test/IPAddressTest.cpp b/folly/test/IPAddressTest.cpp +index fccb969c5..cb377922a 100644 +--- a/folly/test/IPAddressTest.cpp ++++ b/folly/test/IPAddressTest.cpp +@@ -20,7 +20,7 @@ + + #include + +-#include ++#include + + #include + #include +diff --git a/folly/test/MacAddressTest.cpp b/folly/test/MacAddressTest.cpp +index 9ae28aa7b..ec8a4b774 100644 +--- a/folly/test/MacAddressTest.cpp ++++ b/folly/test/MacAddressTest.cpp +@@ -16,7 +16,7 @@ + + #include + +-#include ++#include + + #include + #include +diff --git a/folly/test/MemsetBenchmark.cpp b/folly/test/MemsetBenchmark.cpp +index fd549278f..b261635c8 100644 +--- a/folly/test/MemsetBenchmark.cpp ++++ b/folly/test/MemsetBenchmark.cpp +@@ -20,7 +20,7 @@ + #include + #include + #include +-#include ++#include + #include + #include + #include diff --git a/overlayports/folly/fix-fmt11-cmake.patch b/overlayports/folly/fix-fmt11-cmake.patch deleted file mode 100644 index 03cca936..00000000 --- a/overlayports/folly/fix-fmt11-cmake.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/CMake/GenPkgConfig.cmake b/CMake/GenPkgConfig.cmake -index 0e93175..1637d9f 100644 ---- a/CMake/GenPkgConfig.cmake -+++ b/CMake/GenPkgConfig.cmake -@@ -93,7 +93,7 @@ function(gen_pkgconfig_vars) - # Set the output variables - string(REPLACE ";" " " cflags "${cflags}") - string(REPLACE ";" " " private_libs "${private_libs}") -- -+ string(REPLACE "<$:/utf-8>" "/utf-8" cflags "${cflags}") - # Since CMake 3.18 FindThreads may include a generator expression requiring - # a target, which gets propagated to us through INTERFACE_COMPILE_OPTIONS. - # Before CMake 3.19 there's no way to solve this in a general way, so we diff --git a/overlayports/folly/fix-missing-exception-include.patch b/overlayports/folly/fix-missing-exception-include.patch new file mode 100644 index 00000000..864d3a83 --- /dev/null +++ b/overlayports/folly/fix-missing-exception-include.patch @@ -0,0 +1,16 @@ +folly/result/rich_error_code.h uses std::exception_ptr without including +; libc++ 22 no longer provides it transitively through the other +includes. Compile error under clang-22 + libc++-22: + "no type named 'exception_ptr' in namespace 'std'" +--- a/folly/result/rich_error_code.h ++++ b/folly/result/rich_error_code.h +@@ -14,8 +14,9 @@ + * limitations under the License. + */ + + #pragma once + ++#include + #include + #include + diff --git a/overlayports/folly/fix-perf_scoped-target.patch b/overlayports/folly/fix-perf_scoped-target.patch new file mode 100644 index 00000000..7bd8873c --- /dev/null +++ b/overlayports/folly/fix-perf_scoped-target.patch @@ -0,0 +1,14 @@ +diff --git a/folly/detail/CMakeLists.txt b/folly/detail/CMakeLists.txt +index 521983f..7bbfb6d 100644 +--- a/folly/detail/CMakeLists.txt ++++ b/folly/detail/CMakeLists.txt +@@ -182,6 +182,9 @@ folly_add_library( + EXTERNAL_DEPS + Boost::regex + ) ++if(CMAKE_SYSTEM_NAME STREQUAL "Linux") ++ target_link_libraries(folly_detail_perf_scoped PUBLIC folly_subprocess) ++endif() + + folly_add_library( + NAME poly_detail diff --git a/overlayports/folly/fix-range.patch b/overlayports/folly/fix-range.patch deleted file mode 100644 index 328b5b51..00000000 --- a/overlayports/folly/fix-range.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/folly/Range.h b/folly/Range.h -index 42cd92d69..d87914a99 100644 ---- a/folly/Range.h -+++ b/folly/Range.h -@@ -638,7 +638,7 @@ class Range { - template - struct StringViewType // - : std::conditional< -- std::is_trivial::value, -+ detail::range_is_char_type_v_, - std::basic_string_view, - NotStringView> {}; - diff --git a/overlayports/folly/fix-windows-minmax.patch b/overlayports/folly/fix-windows-minmax.patch deleted file mode 100644 index 1fc69a43..00000000 --- a/overlayports/folly/fix-windows-minmax.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff --git a/CMake/FollyCompilerMSVC.cmake b/CMake/FollyCompilerMSVC.cmake -index ec2ce1a1d..16deda71c 100644 ---- a/CMake/FollyCompilerMSVC.cmake -+++ b/CMake/FollyCompilerMSVC.cmake -@@ -289,6 +289,7 @@ function(apply_folly_compile_options_to_target THETARGET) - # And the extra defines: - target_compile_definitions(${THETARGET} - PUBLIC -+ NOMINMAX - _CRT_NONSTDC_NO_WARNINGS # Don't deprecate posix names of functions. - _CRT_SECURE_NO_WARNINGS # Don't deprecate the non _s versions of various standard library functions, because safety is for chumps. - _SCL_SECURE_NO_WARNINGS # Don't deprecate the non _s versions of various standard library functions, because safety is for chumps. diff --git a/overlayports/folly/portfile.cmake b/overlayports/folly/portfile.cmake index 73b07fb3..fcf555e6 100644 --- a/overlayports/folly/portfile.cmake +++ b/overlayports/folly/portfile.cmake @@ -1,30 +1,22 @@ -vcpkg_check_linkage(ONLY_STATIC_LIBRARY) - -# Required to run build/generate_escape_tables.py et al. -vcpkg_find_acquire_program(PYTHON3) -get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY) -vcpkg_add_to_path("${PYTHON3_DIR}") +if(VCPKG_TARGET_IS_WINDOWS) + vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +endif() vcpkg_from_github( OUT_SOURCE_PATH SOURCE_PATH REPO facebook/folly REF "v${VERSION}" - SHA512 1637fe98a16b44d2be68357b1b07b3d95f7950dbc807158ac82ec935c79d8423e6ed24ebaeb99cc6a8505f301819d3c77a04ba818528d2df84e92c42309fd5f5 + SHA512 8ee08591724fb1f6183cc0456c13cd00474e425d41824add2751fd3823e23b95ea69ec1b246bc85c95d30add854ee53dafd2bc1b824d0b555917dcbaf6943a6f HEAD_REF main PATCHES - disable-non-underscore-posix-names.patch - fix-windows-minmax.patch fix-deps.patch disable-uninitialized-resize-on-new-stl.patch fix-unistd-include.patch - fix-fmt11-cmake.patch - disable-groupvarint.patch - disable-cxa-init-primary-exception.patch - fix-android-remainder.patch - fix-range.patch - fix-cursor.patch + fix-perf_scoped-target.patch + fix-fmt-header.patch + fix-missing-exception-include.patch ) - +file(REMOVE "${SOURCE_PATH}/CMake/FindFastFloat.cmake") file(REMOVE "${SOURCE_PATH}/CMake/FindFmt.cmake") file(REMOVE "${SOURCE_PATH}/CMake/FindLibsodium.cmake") file(REMOVE "${SOURCE_PATH}/CMake/FindZstd.cmake") @@ -35,63 +27,56 @@ file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindGMock.cmake") file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindGflags.cmake") file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindGlog.cmake") file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindLibEvent.cmake") -file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindLibUnwind.cmake") file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindSodium.cmake") file(REMOVE "${SOURCE_PATH}/build/fbcode_builder/CMake/FindZstd.cmake") -if(VCPKG_CRT_LINKAGE STREQUAL static) - set(MSVC_USE_STATIC_RUNTIME ON) -else() - set(MSVC_USE_STATIC_RUNTIME OFF) -endif() +string(COMPARE EQUAL "${VCPKG_CRT_LINKAGE}" "static" MSVC_USE_STATIC_RUNTIME) vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS FEATURES - "zlib" CMAKE_REQUIRE_FIND_PACKAGE_ZLIB - "liburing" WITH_liburing - "libaio" WITH_libaio - INVERTED_FEATURES - "bzip2" CMAKE_DISABLE_FIND_PACKAGE_BZip2 - "lzma" CMAKE_DISABLE_FIND_PACKAGE_LibLZMA - "lz4" CMAKE_DISABLE_FIND_PACKAGE_LZ4 - "zstd" CMAKE_DISABLE_FIND_PACKAGE_Zstd - "snappy" CMAKE_DISABLE_FIND_PACKAGE_Snappy - "libsodium" CMAKE_DISABLE_FIND_PACKAGE_unofficial-sodium + "bzip2" VCPKG_LOCK_FIND_PACKAGE_BZip2 + "libaio" VCPKG_LOCK_FIND_PACKAGE_LibAIO + "libsodium" VCPKG_LOCK_FIND_PACKAGE_LIBSODIUM + "liburing" VCPKG_LOCK_FIND_PACKAGE_LibUring + "lz4" VCPKG_LOCK_FIND_PACKAGE_LZ4 + "snappy" VCPKG_LOCK_FIND_PACKAGE_SNAPPY + "zstd" VCPKG_LOCK_FIND_PACKAGE_ZSTD ) +set(CROSSCOMP_OPTIONS "") +if(VCPKG_CROSSCOMPILING AND VCPKG_TARGET_IS_LINUX) + # Seed try_run results for cross-compiling; binaries cannot execute on the build host. + set(CROSSCOMP_OPTIONS + -DFOLLY_HAVE_UNALIGNED_ACCESS_EXITCODE=0 + -DFOLLY_HAVE_WEAK_SYMBOLS_EXITCODE=0 + -DFOLLY_HAVE_LINUX_VDSO_EXITCODE=0 + -DFOLLY_HAVE_WCHAR_SUPPORT_EXITCODE=0 + -DHAVE_VSNPRINTF_ERRORS_EXITCODE=0 + ) +endif() vcpkg_cmake_configure( SOURCE_PATH "${SOURCE_PATH}" OPTIONS -DMSVC_USE_STATIC_RUNTIME=${MSVC_USE_STATIC_RUNTIME} - -DCMAKE_DISABLE_FIND_PACKAGE_LibDwarf=ON - -DCMAKE_DISABLE_FIND_PACKAGE_Libiberty=ON -DCMAKE_INSTALL_DIR=share/folly + -DFOLLY_NO_EXCEPTION_TRACER=ON + -DCMAKE_POLICY_DEFAULT_CMP0167=NEW + -DVCPKG_LOCK_FIND_PACKAGE_fmt=ON + -DVCPKG_LOCK_FIND_PACKAGE_LibDwarf=OFF + -DVCPKG_LOCK_FIND_PACKAGE_Libiberty=OFF + -DVCPKG_LOCK_FIND_PACKAGE_LibUnwind=${VCPKG_TARGET_IS_LINUX} + -DVCPKG_LOCK_FIND_PACKAGE_ZLIB=ON ${FEATURE_OPTIONS} + ${CROSSCOMP_OPTIONS} MAYBE_UNUSED_VARIABLES MSVC_USE_STATIC_RUNTIME ) -vcpkg_cmake_install(ADD_BIN_TO_PATH) - +vcpkg_cmake_install() vcpkg_copy_pdbs() - -configure_file("${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake" "${CURRENT_PACKAGES_DIR}/share/${PORT}/vcpkg-cmake-wrapper.cmake" @ONLY) - +vcpkg_fixup_pkgconfig() vcpkg_cmake_config_fixup() -# Release folly-targets.cmake does not link to the right libraries in debug mode. -# We substitute with generator expressions so that the right libraries are linked for debug and release. -set(FOLLY_TARGETS_CMAKE "${CURRENT_PACKAGES_DIR}/share/folly/folly-targets.cmake") -FILE(READ ${FOLLY_TARGETS_CMAKE} _contents) -string(REPLACE "\${VCPKG_IMPORT_PREFIX}/lib/zlib.lib" "ZLIB::ZLIB" _contents "${_contents}") -STRING(REPLACE "\${VCPKG_IMPORT_PREFIX}/lib/" "\${VCPKG_IMPORT_PREFIX}/\$<\$:debug/>lib/" _contents "${_contents}") -STRING(REPLACE "\${VCPKG_IMPORT_PREFIX}/debug/lib/" "\${VCPKG_IMPORT_PREFIX}/\$<\$:debug/>lib/" _contents "${_contents}") -string(REPLACE "-vc140-mt.lib" "-vc140-mt\$<\$:-gd>.lib" _contents "${_contents}") -FILE(WRITE ${FOLLY_TARGETS_CMAKE} "${_contents}") - file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") -# Handle copyright vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/LICENSE") - -vcpkg_fixup_pkgconfig() diff --git a/overlayports/folly/vcpkg-cmake-wrapper.cmake b/overlayports/folly/vcpkg-cmake-wrapper.cmake deleted file mode 100644 index cce45a2e..00000000 --- a/overlayports/folly/vcpkg-cmake-wrapper.cmake +++ /dev/null @@ -1,6 +0,0 @@ -set(FOLLY_PREV_MODULE_PATH ${CMAKE_MODULE_PATH}) -list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}) - -_find_package(${ARGS}) - -set(CMAKE_MODULE_PATH ${FOLLY_PREV_MODULE_PATH}) \ No newline at end of file diff --git a/overlayports/folly/vcpkg.json b/overlayports/folly/vcpkg.json index 2cc19d5b..717ac0af 100644 --- a/overlayports/folly/vcpkg.json +++ b/overlayports/folly/vcpkg.json @@ -1,10 +1,11 @@ { "name": "folly", - "version-string": "2024.08.19.00", + "version-string": "2026.02.23.00", + "port-version": 2, "description": "An open-source C++ library developed and used at Facebook. The library is UNSTABLE on Windows", "homepage": "https://github.com/facebook/folly", "license": "Apache-2.0", - "supports": "(windows & x64 & !uwp) | (!windows & (x64 | arm64))", + "supports": "(windows & x64 & !uwp & !mingw) | (!windows & !android & (x64 | arm64))", "dependencies": [ "boost-chrono", "boost-context", @@ -20,10 +21,16 @@ "boost-thread", "boost-variant", "double-conversion", + "fast-float", "fmt", "gflags", "glog", "libevent", + "liblzma", + { + "name": "libunwind", + "platform": "linux" + }, "openssl", { "name": "vcpkg-cmake", @@ -32,9 +39,7 @@ { "name": "vcpkg-cmake-config", "host": true - } - ], - "default-features": [ + }, "zlib" ], "features": { @@ -79,13 +84,12 @@ "snappy": { "description": "Support Snappy for compression", "dependencies": [ - "snappy" - ] - }, - "zlib": { - "description": "Support zlib for compression", - "dependencies": [ - "zlib" + { + "name": "snappy", + "features": [ + "rtti" + ] + } ] }, "zstd": { diff --git a/overlayports/libdatachannel/dependencies.diff b/overlayports/libdatachannel/dependencies.diff deleted file mode 100644 index 01ea420c..00000000 --- a/overlayports/libdatachannel/dependencies.diff +++ /dev/null @@ -1,63 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 8a61757..b35e4b1 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -234,7 +234,7 @@ set(THREADS_PREFER_PTHREAD_FLAG TRUE) - find_package(Threads REQUIRED) - - if(USE_SYSTEM_PLOG) -- find_package(plog REQUIRED) -+ find_package(plog CONFIG REQUIRED) - else() - set(CMAKE_POLICY_DEFAULT_CMP0048 NEW) - add_subdirectory(deps/plog EXCLUDE_FROM_ALL) -@@ -245,7 +245,8 @@ if(SCTP_DEBUG) - endif() - - if(USE_SYSTEM_USRSCTP) -- find_package(Usrsctp REQUIRED) -+ find_package(unofficial-usrsctp CONFIG REQUIRED) -+ add_library(Usrsctp::Usrsctp ALIAS unofficial::usrsctp::usrsctp) - else() - option(sctp_build_shared_lib OFF) - option(sctp_build_programs OFF) -@@ -331,7 +332,7 @@ else() - target_compile_definitions(datachannel PUBLIC RTC_ENABLE_MEDIA=1) - target_compile_definitions(datachannel-static PUBLIC RTC_ENABLE_MEDIA=1) - if(USE_SYSTEM_SRTP) -- find_package(libSRTP REQUIRED) -+ find_package(libSRTP CONFIG REQUIRED) - if(NOT TARGET libSRTP::srtp2) - add_library(libSRTP::srtp2 UNKNOWN IMPORTED) - set_target_properties(libSRTP::srtp2 PROPERTIES -@@ -475,8 +476,9 @@ install( - ) - - # Export config -+configure_file(cmake/LibDataChannelConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/cmake/LibDataChannelConfig.cmake @ONLY) - install( -- FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/LibDataChannelConfig.cmake -+ FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/LibDataChannelConfig.cmake - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/LibDataChannel - ) - -diff --git a/cmake/LibDataChannelConfig.cmake b/cmake/LibDataChannelConfig.cmake -index cb2b884..d0b77ca 100644 ---- a/cmake/LibDataChannelConfig.cmake -+++ b/cmake/LibDataChannelConfig.cmake -@@ -1,2 +1,15 @@ -+if(NOT "@BUILD_SHARED_LIBS@") -+ include(CMakeFindDependencyMacro) -+ set(THREADS_PREFER_PTHREAD_FLAG ON) -+ find_dependency(Threads) -+ find_dependency(plog CONFIG) -+ find_dependency(unofficial-usrsctp CONFIG) -+ if(NOT "@NO_MEDIA@") -+ find_dependency(libSRTP CONFIG) -+ endif() -+ find_dependency(OpenSSL) -+ find_dependency(LibJuice) -+endif() -+ - include("${CMAKE_CURRENT_LIST_DIR}/LibDataChannelTargets.cmake") - diff --git a/overlayports/libdatachannel/fix-cmakelists.patch b/overlayports/libdatachannel/fix-cmakelists.patch deleted file mode 100644 index 1880299a..00000000 --- a/overlayports/libdatachannel/fix-cmakelists.patch +++ /dev/null @@ -1,22 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 38e069e..0ada768 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -260,10 +260,14 @@ else() - add_library(Usrsctp::Usrsctp ALIAS usrsctp) - endif() - --configure_file ( -- ${PROJECT_SOURCE_DIR}/cmake/version.h.in -- ${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/version.h -+# COPYONLY (no substitution) and only-written-if-different: vcpkg configures -+# debug and release in parallel from the same source tree, so this step must -+# be idempotent and race-free (the previous REMOVE/COPY/RENAME dance raced). -+configure_file( -+ ${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.h.in -+ ${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/version.h -+ COPYONLY - ) - - add_library(datachannel SHARED - ${LIBDATACHANNEL_SOURCES} diff --git a/overlayports/libdatachannel/library-linkage.diff b/overlayports/libdatachannel/library-linkage.diff deleted file mode 100644 index 655c0320..00000000 --- a/overlayports/libdatachannel/library-linkage.diff +++ /dev/null @@ -1,30 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index b35e4b1..b052d02 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -48,7 +48,6 @@ endif() - - list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) - set(CMAKE_POSITION_INDEPENDENT_CODE ON) --set(BUILD_SHARED_LIBS OFF) # to force usrsctp to be built static - - if(WIN32) - add_definitions(-DWIN32_LEAN_AND_MEAN) -@@ -457,11 +456,17 @@ if(WARNINGS_AS_ERRORS) - endif() - endif() - -+if(BUILD_SHARED_LIBS) - install(TARGETS datachannel EXPORT LibDataChannelTargets - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - ) -+else() -+ set_target_properties(datachannel PROPERTIES EXCLUDE_FROM_ALL 1) -+ set_target_properties(datachannel-static PROPERTIES EXCLUDE_FROM_ALL 0) -+ install(TARGETS datachannel-static EXPORT LibDataChannelTargets) -+endif() - - install(FILES ${LIBDATACHANNEL_HEADERS} - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/rtc diff --git a/overlayports/libdatachannel/portfile.cmake b/overlayports/libdatachannel/portfile.cmake deleted file mode 100644 index 5967b715..00000000 --- a/overlayports/libdatachannel/portfile.cmake +++ /dev/null @@ -1,42 +0,0 @@ -vcpkg_from_github( - OUT_SOURCE_PATH SOURCE_PATH - REPO paullouisageneau/libdatachannel - REF "v${VERSION}" - SHA512 fd0d66bb932e29abc01e9f1a8b16ccb79012a7e3901e2e0f882f56ab2f090260945e1556c85ad07ef897b8c70fcdd44cdeead9955a9bca7afe1dda8900c473cc - HEAD_REF master - PATCHES - dependencies.diff - library-linkage.diff - uwp-warnings.patch - fix-cmakelists.patch -) - -vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS - FEATURES - stdcall CAPI_STDCALL - INVERTED_FEATURES - ws NO_WEBSOCKET - srtp NO_MEDIA -) - -vcpkg_cmake_configure( - SOURCE_PATH "${SOURCE_PATH}" - OPTIONS - ${FEATURE_OPTIONS} - -DPREFER_SYSTEM_LIB=ON - -DNO_EXAMPLES=ON - -DNO_TESTS=ON -) - -vcpkg_cmake_install() -vcpkg_cmake_config_fixup(CONFIG_PATH lib/cmake/LibDataChannel) -vcpkg_fixup_pkgconfig() - -if(VCPKG_LIBRARY_LINKAGE STREQUAL "static") - vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/include/rtc/common.hpp" "#ifdef RTC_STATIC" "#if 1") - vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/include/rtc/rtc.h" "#ifdef RTC_STATIC" "#if 1") -endif() - -file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include" "${CURRENT_PACKAGES_DIR}/debug/share") - -vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/LICENSE") diff --git a/overlayports/libdatachannel/uwp-warnings.patch b/overlayports/libdatachannel/uwp-warnings.patch deleted file mode 100644 index 23d23dd3..00000000 --- a/overlayports/libdatachannel/uwp-warnings.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 1b5190b..763b49e 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -315,6 +315,10 @@ target_link_libraries(datachannel-static PRIVATE Usrsctp::Usrsctp plog::plog) - if(WIN32) - target_link_libraries(datachannel PUBLIC ws2_32) # winsock2 - target_link_libraries(datachannel-static PUBLIC ws2_32) # winsock2 -+ if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") -+ target_compile_options(datachannel PRIVATE /wd4996) -+ target_compile_options(datachannel-static PRIVATE /wd4996) -+ endif() - endif() - - if (NO_WEBSOCKET) diff --git a/overlayports/libdatachannel/vcpkg.json b/overlayports/libdatachannel/vcpkg.json deleted file mode 100644 index 71d55e0f..00000000 --- a/overlayports/libdatachannel/vcpkg.json +++ /dev/null @@ -1,41 +0,0 @@ -{ - "name": "libdatachannel", - "version-semver": "0.21.2", - "port-version": 1, - "description": "libdatachannel is a standalone implementation of WebRTC Data Channels, WebRTC Media Transport, and WebSockets in C++17 with C bindings for POSIX platforms (including GNU/Linux, Android, and Apple macOS) and Microsoft Windows.", - "homepage": "https://github.com/paullouisageneau/libdatachannel", - "license": "MPL-2.0", - "supports": "!xbox", - "dependencies": [ - "libjuice", - "nlohmann-json", - "openssl", - "plog", - "usrsctp", - { - "name": "vcpkg-cmake", - "host": true - }, - { - "name": "vcpkg-cmake-config", - "host": true - } - ], - "default-features": [ - "ws" - ], - "features": { - "srtp": { - "description": "Use Cisco's libSRTP for media transport.", - "dependencies": [ - "libsrtp" - ] - }, - "stdcall": { - "description": "Use stdcall convention in callbacks" - }, - "ws": { - "description": "Web Socket support" - } - } -} diff --git a/overlayports/magic-enum/portfile.cmake b/overlayports/magic-enum/portfile.cmake deleted file mode 100644 index 15c3bf44..00000000 --- a/overlayports/magic-enum/portfile.cmake +++ /dev/null @@ -1,27 +0,0 @@ -vcpkg_from_github( - OUT_SOURCE_PATH SOURCE_PATH - REPO Neargye/magic_enum - REF "v${VERSION}" - SHA512 fa3792e9c69c57e437d6325b7659cf25e6cbdda3326ffeaf0411d9838822095b15306f322ad2ebd5ec68b905ef2aed08880d2507e7d8a8559ab3c5be6c8ce99c - HEAD_REF master -) - -set(VCPKG_BUILD_TYPE release) # header-only port - -vcpkg_cmake_configure( - SOURCE_PATH "${SOURCE_PATH}" - OPTIONS - -DMAGIC_ENUM_OPT_BUILD_EXAMPLES=OFF - -DMAGIC_ENUM_OPT_BUILD_TESTS=OFF - -DMAGIC_ENUM_OPT_INSTALL=ON -) - -vcpkg_cmake_install() - -vcpkg_cmake_config_fixup(CONFIG_PATH lib/cmake/magic_enum PACKAGE_NAME magic_enum) - -file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/lib") - -# Handle copyright -configure_file("${SOURCE_PATH}/LICENSE" "${CURRENT_PACKAGES_DIR}/share/${PORT}/copyright" COPYONLY) -file(INSTALL "${CMAKE_CURRENT_LIST_DIR}/usage" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}") diff --git a/overlayports/magic-enum/usage b/overlayports/magic-enum/usage deleted file mode 100644 index 3d3a94b5..00000000 --- a/overlayports/magic-enum/usage +++ /dev/null @@ -1,4 +0,0 @@ -magic-enum provides CMake targets: - - find_package(magic_enum CONFIG REQUIRED) - target_link_libraries(main PRIVATE magic_enum::magic_enum) diff --git a/overlayports/magic-enum/vcpkg.json b/overlayports/magic-enum/vcpkg.json deleted file mode 100644 index 806f787f..00000000 --- a/overlayports/magic-enum/vcpkg.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "name": "magic-enum", - "version": "0.9.6", - "description": "Header-only C++17 library provides static reflection for enums, work with any enum type without any macro or boilerplate code.", - "homepage": "https://github.com/Neargye/magic_enum", - "license": "MIT", - "dependencies": [ - { - "name": "vcpkg-cmake", - "host": true - }, - { - "name": "vcpkg-cmake-config", - "host": true - } - ] -} diff --git a/overlayports/secp256k1/JUSTIFICATION.md b/overlayports/secp256k1/JUSTIFICATION.md new file mode 100644 index 00000000..9c391654 --- /dev/null +++ b/overlayports/secp256k1/JUSTIFICATION.md @@ -0,0 +1,10 @@ +# Why this overlay exists + +Baseline: vcpkg 2026.06.24 (secp256k1 0.7.1). Identical to the upstream port +except one added configure option: + +- `-DSECP256K1_ENABLE_MODULE_RECOVERY=ON`: upstream secp256k1 disables the + recovery module by default and the vcpkg port does not enable it; + streamr-utils/SigningUtils.hpp needs (ECDSA + public-key recovery). Remove if the upstream port gains a "recovery" + feature. diff --git a/overlayports/secp256k1/portfile.cmake b/overlayports/secp256k1/portfile.cmake new file mode 100644 index 00000000..01b8871f --- /dev/null +++ b/overlayports/secp256k1/portfile.cmake @@ -0,0 +1,26 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) + +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO bitcoin-core/secp256k1 + REF v${VERSION} + SHA512 747bda9276c02a87511c2d3275ec8894db1b7b99dcc9ab9a48497659c2eb512c555cc5f5f2c0269b00237e7177aa3790a5c7cf635ee695f2d440f0ddcb8672ab +) + +vcpkg_cmake_configure( + SOURCE_PATH "${SOURCE_PATH}" + OPTIONS + -DSECP256K1_ENABLE_MODULE_RECOVERY=ON + -DSECP256K1_BUILD_BENCHMARK=OFF + -DSECP256K1_BUILD_TESTS=OFF + -DSECP256K1_BUILD_EXHAUSTIVE_TESTS=OFF +) + +vcpkg_cmake_install() + +vcpkg_cmake_config_fixup(CONFIG_PATH "lib/cmake/libsecp256k1" PACKAGE_NAME libsecp256k1) +vcpkg_fixup_pkgconfig() + +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include" "${CURRENT_PACKAGES_DIR}/debug/share") + +file(INSTALL "${SOURCE_PATH}/COPYING" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright) diff --git a/overlayports/secp256k1/vcpkg.json b/overlayports/secp256k1/vcpkg.json new file mode 100644 index 00000000..a7048092 --- /dev/null +++ b/overlayports/secp256k1/vcpkg.json @@ -0,0 +1,17 @@ +{ + "name": "secp256k1", + "version": "0.7.1", + "description": "Optimized C library for EC operations on curve", + "homepage": "https://github.com/bitcoin-core/secp256k1", + "license": "MIT", + "dependencies": [ + { + "name": "vcpkg-cmake", + "host": true + }, + { + "name": "vcpkg-cmake-config", + "host": true + } + ] +} diff --git a/overlayports/usrsctp/JUSTIFICATION.md b/overlayports/usrsctp/JUSTIFICATION.md new file mode 100644 index 00000000..2f4f75bf --- /dev/null +++ b/overlayports/usrsctp/JUSTIFICATION.md @@ -0,0 +1,13 @@ +# Why this overlay exists + +Baseline: vcpkg 2026.06.24 (usrsctp 0.9.5.0). Identical to the upstream port +except two added patches carried over from the pre-2026 overlay (verified +still required — the iOS SDK ships neither header): + +- `fix-missing-route-header-ios.patch`: iPhoneOS SDK has no ; + provides the few routing-socket constants user_recv_thread.c needs. + ("fatal error: 'net/route.h' file not found" on arm64-ios.) +- `add-iffaddrs-include.patch`: sctp_bsd_addr.c uses getifaddrs without + including , which other platforms receive transitively. + +Remove if upstream usrsctp gains iOS support. diff --git a/overlayports/usrsctp/fix-cmake-version.patch b/overlayports/usrsctp/fix-cmake-version.patch deleted file mode 100644 index 368ac9a0..00000000 --- a/overlayports/usrsctp/fix-cmake-version.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index ba935f5..3b2631d 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -29,8 +29,9 @@ - # SUCH DAMAGE. - # - -+cmake_minimum_required(VERSION 3.22) -+cmake_policy(SET CMP0057 NEW) - project(usrsctplib C) --cmake_minimum_required(VERSION 3.0) - - # Debug build type as default - if (NOT CMAKE_BUILD_TYPE) diff --git a/overlayports/usrsctp/portfile.cmake b/overlayports/usrsctp/portfile.cmake index 5cb1cbff..eb47c464 100644 --- a/overlayports/usrsctp/portfile.cmake +++ b/overlayports/usrsctp/portfile.cmake @@ -10,7 +10,6 @@ vcpkg_from_github( fix_export.patch mingw.diff fix-missing-route-header-ios.patch - fix-cmake-version.patch add-iffaddrs-include.patch ) diff --git a/overlaytriplets/arm64-ios.cmake b/overlaytriplets/arm64-ios.cmake index 6212e5da..4ec6aa83 100644 --- a/overlaytriplets/arm64-ios.cmake +++ b/overlaytriplets/arm64-ios.cmake @@ -20,7 +20,7 @@ set(CMAKE_CXX_COMPILER "${LLVM_PREFIX}/bin/clang++") set(ENV{CC} "${CMAKE_C_COMPILER}") set(ENV{CXX} "${CMAKE_CXX_COMPILER}") -set(VCPKG_CMAKE_CONFIGURE_OPTIONS -DCMAKE_C_COMPILER=${LLVM_PREFIX}/bin/clang -DCMAKE_CXX_COMPILER=${LLVM_PREFIX}/bin/clang++ -DCMAKE_CXX_STANDARD=26 -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_MOBILE=0 -DIS_AARCH64_ARCH=0 -D__APPLE__=1 -DFOLLY_HAVE_MALLOC_USABLE_SIZE=0 -DPLATFORM=OS64) +set(VCPKG_CMAKE_CONFIGURE_OPTIONS -DCMAKE_C_COMPILER=${LLVM_PREFIX}/bin/clang -DCMAKE_CXX_COMPILER=${LLVM_PREFIX}/bin/clang++ -DCMAKE_CXX_STANDARD=26 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_MOBILE=0 -DIS_AARCH64_ARCH=0 -D__APPLE__=1 -DFOLLY_HAVE_MALLOC_USABLE_SIZE=0 -DPLATFORM=OS64) set(VCPKG_CXX_FLAGS "-isystem ${LLVM_PREFIX}/include/c++/v1 -DFOLLY_MOBILE=0 -D_LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION=0") set(VCPKG_C_FLAGS "-isystem ${LLVM_PREFIX}/include/c++/v1 -DFOLLY_MOBILE=0 -D_LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION=0") diff --git a/overlaytriplets/arm64-osx.cmake b/overlaytriplets/arm64-osx.cmake index cd607033..e09e2604 100644 --- a/overlaytriplets/arm64-osx.cmake +++ b/overlaytriplets/arm64-osx.cmake @@ -4,10 +4,6 @@ set(VCPKG_LIBRARY_LINKAGE static) set(VCPKG_CMAKE_SYSTEM_NAME Darwin) set(VCPKG_OSX_ARCHITECTURES arm64) -# CMake 4 no longer defaults CMAKE_OSX_SYSROOT to the SDK path; the pinned -# vcpkg scripts compose "-isysroot ${CMAKE_OSX_SYSROOT}" unconditionally, -# which breaks with an empty value. Name the SDK explicitly. -set(VCPKG_OSX_SYSROOT macosx) set(CMAKE_CXX_STANDARD 26) set(HOMEBREW_PREFIX $ENV{HOMEBREW_PREFIX}) @@ -26,7 +22,7 @@ set(ENV{CXX} "${CMAKE_CXX_COMPILER}") set(VCPKG_CMAKE_CONFIGURE_OPTIONS -DCMAKE_C_COMPILER=${LLVM_PREFIX}/bin/clang -DCMAKE_CXX_COMPILER=${LLVM_PREFIX}/bin/clang++ - -DCMAKE_CXX_STANDARD=26 -DCMAKE_POLICY_VERSION_MINIMUM=3.5 + -DCMAKE_CXX_STANDARD=26 ) set(VCPKG_CXX_FLAGS "-isystem ${LLVM_PREFIX}/include/c++/v1") diff --git a/overlaytriplets/x64-osx.cmake b/overlaytriplets/x64-osx.cmake index 7b5b1e4f..c903af3c 100644 --- a/overlaytriplets/x64-osx.cmake +++ b/overlaytriplets/x64-osx.cmake @@ -4,10 +4,6 @@ set(VCPKG_LIBRARY_LINKAGE static) set(VCPKG_CMAKE_SYSTEM_NAME Darwin) set(VCPKG_OSX_ARCHITECTURES x86_64) -# CMake 4 no longer defaults CMAKE_OSX_SYSROOT to the SDK path; the pinned -# vcpkg scripts compose "-isysroot ${CMAKE_OSX_SYSROOT}" unconditionally, -# which breaks with an empty value. Name the SDK explicitly. -set(VCPKG_OSX_SYSROOT macosx) set(CMAKE_CXX_STANDARD 26) set(HOMEBREW_PREFIX $ENV{HOMEBREW_PREFIX}) @@ -23,7 +19,7 @@ set(CMAKE_CXX_COMPILER "${LLVM_PREFIX}/bin/clang++") set(ENV{CC} "${CMAKE_C_COMPILER}") set(ENV{CXX} "${CMAKE_CXX_COMPILER}") -set(VCPKG_CMAKE_CONFIGURE_OPTIONS -DCMAKE_C_COMPILER=${LLVM_PREFIX}/bin/clang -DCMAKE_CXX_COMPILER=${LLVM_PREFIX}/bin/clang++ -DCMAKE_CXX_STANDARD=26 -DCMAKE_POLICY_VERSION_MINIMUM=3.5) +set(VCPKG_CMAKE_CONFIGURE_OPTIONS -DCMAKE_C_COMPILER=${LLVM_PREFIX}/bin/clang -DCMAKE_CXX_COMPILER=${LLVM_PREFIX}/bin/clang++ -DCMAKE_CXX_STANDARD=26) set(VCPKG_CXX_FLAGS "-isystem ${LLVM_PREFIX}/include/c++/v1") set(VCPKG_C_FLAGS "-isystem ${LLVM_PREFIX}/include/c++/v1") diff --git a/packages/streamr-dht/CMakeLists.txt b/packages/streamr-dht/CMakeLists.txt index 649817f3..af77b927 100644 --- a/packages/streamr-dht/CMakeLists.txt +++ b/packages/streamr-dht/CMakeLists.txt @@ -60,13 +60,12 @@ target_link_libraries(streamr-dht PUBLIC streamr::streamr-proto-rpc INTERFACE streamr::streamr-utils PRIVATE protobuf::libprotobuf - PRIVATE protobuf::libprotoc INTERFACE Boost::uuid INTERFACE Boost::algorithm PRIVATE magic_enum::magic_enum PRIVATE Folly::folly PRIVATE OpenSSL::Crypto - PRIVATE LibDataChannel::LibDataChannelStatic + PRIVATE LibDataChannel::LibDataChannel INTERFACE ipaddress::ipaddress ) diff --git a/packages/streamr-dht/include/streamr-dht/connection/Connection.hpp b/packages/streamr-dht/include/streamr-dht/connection/Connection.hpp index 2c3de6e0..c80ce2d5 100644 --- a/packages/streamr-dht/include/streamr-dht/connection/Connection.hpp +++ b/packages/streamr-dht/include/streamr-dht/connection/Connection.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include "streamr-eventemitter/EventEmitter.hpp" #include "streamr-logger/SLogger.hpp" #include "streamr-utils/Branded.hpp" diff --git a/packages/streamr-dht/include/streamr-dht/helpers/Errors.hpp b/packages/streamr-dht/include/streamr-dht/helpers/Errors.hpp index beeef688..cb81a640 100644 --- a/packages/streamr-dht/include/streamr-dht/helpers/Errors.hpp +++ b/packages/streamr-dht/include/streamr-dht/helpers/Errors.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include namespace streamr::dht::helpers { diff --git a/packages/streamr-dht/proto.sh b/packages/streamr-dht/proto.sh index d29ebf19..96100466 100755 --- a/packages/streamr-dht/proto.sh +++ b/packages/streamr-dht/proto.sh @@ -1,4 +1,6 @@ -PROTOC=../../build/vcpkg_installed/arm64-osx/tools/protobuf/protoc +# Use the protoc that matches the installed libprotobuf; triplet detected +# from the monorepo build dir (override with PROTOC=... if needed). +PROTOC=${PROTOC:-$(ls ../../build/vcpkg_installed/*/tools/protobuf/protoc 2>/dev/null | head -1)} #PLUGIN=../../build/packages/streamr-proto-rpc/protobuf-streamr-plugin PLUGIN=../streamr-proto-rpc/build/protobuf-streamr-plugin mkdir -p ./src/proto @@ -10,18 +12,18 @@ mkdir -p protos/packages/proto-rpc/protos mkdir -p protos/packages/dht/protos cp -r ../streamr-proto-rpc/protos/* protos/packages/proto-rpc/protos cp protos/DhtRpc.proto protos/packages/dht/protos -${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./src/proto/packages/dht/protos --proto_path=./protos --cpp_out=./src/proto packages/dht/protos/DhtRpc.proto --experimental_allow_proto3_optional -${PROTOC} --proto_path=./protos --cpp_out=./src/proto packages/proto-rpc/protos/ProtoRpc.proto --experimental_allow_proto3_optional +${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./src/proto/packages/dht/protos --proto_path=./protos --cpp_out=./src/proto packages/dht/protos/DhtRpc.proto +${PROTOC} --proto_path=./protos --cpp_out=./src/proto packages/proto-rpc/protos/ProtoRpc.proto rm -rf protos/packages #mkdir -p ./test/proto -#${PROTOC} -I=test/protos --cpp_out=./test/proto test/protos/*.proto --experimental_allow_proto3_optional -#${PROTOC} --plugin=protoc-gen-streamr=./build/protobuf-streamr-plugin --streamr_out=./test/proto --proto_path=test/protos test/protos/*.proto --experimental_allow_proto3_optional +#${PROTOC} -I=test/protos --cpp_out=./test/proto test/protos/*.proto +#${PROTOC} --plugin=protoc-gen-streamr=./build/protobuf-streamr-plugin --streamr_out=./test/proto --proto_path=test/protos test/protos/*.proto #mkdir -p ./examples/hello/proto -#${PROTOC} -I=examples/hello --cpp_out=./examples/hello/proto examples/hello/*.proto --experimental_allow_proto3_optional -#${PROTOC} --plugin=protoc-gen-streamr=./build/protobuf-streamr-plugin --streamr_out=./examples/hello/proto --proto_path=examples/hello examples/hello/*.proto --experimental_allow_proto3_optional +#${PROTOC} -I=examples/hello --cpp_out=./examples/hello/proto examples/hello/*.proto +#${PROTOC} --plugin=protoc-gen-streamr=./build/protobuf-streamr-plugin --streamr_out=./examples/hello/proto --proto_path=examples/hello examples/hello/*.proto #mkdir -p ./examples/routed-hello/proto -#${PROTOC} -I=examples/routed-hello --cpp_out=./examples/routed-hello/proto examples/routed-hello/*.proto --experimental_allow_proto3_optional -#${PROTOC} --plugin=protoc-gen-streamr=./build/protobuf-streamr-plugin --streamr_out=./examples/routed-hello/proto --proto_path=examples/routed-hello examples/routed-hello/*.proto --experimental_allow_proto3_optional +#${PROTOC} -I=examples/routed-hello --cpp_out=./examples/routed-hello/proto examples/routed-hello/*.proto +#${PROTOC} --plugin=protoc-gen-streamr=./build/protobuf-streamr-plugin --streamr_out=./examples/routed-hello/proto --proto_path=examples/routed-hello examples/routed-hello/*.proto diff --git a/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.cc b/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.cc index fd2d00b9..be005b54 100644 --- a/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.cc +++ b/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/dht/protos/DhtRpc.proto +// Protobuf C++ Version: 6.33.4 #include "packages/dht/protos/DhtRpc.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" @@ -18,9 +23,16 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; namespace dht { - template -PROTOBUF_CONSTEXPR WebsocketConnectionRequest::WebsocketConnectionRequest(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR WebsocketConnectionRequest::WebsocketConnectionRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(WebsocketConnectionRequest_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct WebsocketConnectionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR WebsocketConnectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~WebsocketConnectionRequestDefaultTypeInternal() {} @@ -31,8 +43,14 @@ struct WebsocketConnectionRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebsocketConnectionRequestDefaultTypeInternal _WebsocketConnectionRequest_default_instance_; - template -PROTOBUF_CONSTEXPR WebrtcConnectionRequest::WebrtcConnectionRequest(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR WebrtcConnectionRequest::WebrtcConnectionRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(WebrtcConnectionRequest_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct WebrtcConnectionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR WebrtcConnectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~WebrtcConnectionRequestDefaultTypeInternal() {} @@ -46,14 +64,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr UnlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : lockid_( + : _cached_size_{0}, + lockid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR UnlockRequest::UnlockRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(UnlockRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct UnlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR UnlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~UnlockRequestDefaultTypeInternal() {} @@ -64,8 +88,14 @@ struct UnlockRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnlockRequestDefaultTypeInternal _UnlockRequest_default_instance_; - template -PROTOBUF_CONSTEXPR StoreDataResponse::StoreDataResponse(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR StoreDataResponse::StoreDataResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(StoreDataResponse_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct StoreDataResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR StoreDataResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StoreDataResponseDefaultTypeInternal() {} @@ -79,17 +109,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RtcOffer::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : description_( + : _cached_size_{0}, + description_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), connectionid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR RtcOffer::RtcOffer(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RtcOffer_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RtcOfferDefaultTypeInternal { PROTOBUF_CONSTEXPR RtcOfferDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RtcOfferDefaultTypeInternal() {} @@ -103,17 +139,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RtcAnswer::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : description_( + : _cached_size_{0}, + description_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), connectionid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR RtcAnswer::RtcAnswer(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RtcAnswer_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RtcAnswerDefaultTypeInternal { PROTOBUF_CONSTEXPR RtcAnswerDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RtcAnswerDefaultTypeInternal() {} @@ -135,7 +177,13 @@ inline constexpr RouteMessageAck::Impl_::Impl_( template PROTOBUF_CONSTEXPR RouteMessageAck::RouteMessageAck(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RouteMessageAck_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RouteMessageAckDefaultTypeInternal { PROTOBUF_CONSTEXPR RouteMessageAckDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RouteMessageAckDefaultTypeInternal() {} @@ -149,15 +197,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RecursiveOperationRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : sessionid_( + : _cached_size_{0}, + sessionid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - operation_{static_cast< ::dht::RecursiveOperation >(0)}, - _cached_size_{0} {} + operation_{static_cast< ::dht::RecursiveOperation >(0)} {} template PROTOBUF_CONSTEXPR RecursiveOperationRequest::RecursiveOperationRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RecursiveOperationRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RecursiveOperationRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR RecursiveOperationRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RecursiveOperationRequestDefaultTypeInternal() {} @@ -171,14 +225,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr PingResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : requestid_( + : _cached_size_{0}, + requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR PingResponse::PingResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PingResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PingResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR PingResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PingResponseDefaultTypeInternal() {} @@ -192,14 +252,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr PingRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : requestid_( + : _cached_size_{0}, + requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR PingRequest::PingRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PingRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PingRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PingRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PingRequestDefaultTypeInternal() {} @@ -213,12 +279,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr LockResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : accepted_{false}, - _cached_size_{0} {} + : _cached_size_{0}, + accepted_{false} {} template PROTOBUF_CONSTEXPR LockResponse::LockResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(LockResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct LockResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR LockResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LockResponseDefaultTypeInternal() {} @@ -232,14 +304,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr LockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : lockid_( + : _cached_size_{0}, + lockid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR LockRequest::LockRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(LockRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct LockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR LockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LockRequestDefaultTypeInternal() {} @@ -250,8 +328,14 @@ struct LockRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LockRequestDefaultTypeInternal _LockRequest_default_instance_; - template -PROTOBUF_CONSTEXPR LeaveNotice::LeaveNotice(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR LeaveNotice::LeaveNotice(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(LeaveNotice_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct LeaveNoticeDefaultTypeInternal { PROTOBUF_CONSTEXPR LeaveNoticeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LeaveNoticeDefaultTypeInternal() {} @@ -265,7 +349,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr IceCandidate::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : candidate_( + : _cached_size_{0}, + candidate_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), mid_( @@ -273,12 +358,17 @@ inline constexpr IceCandidate::Impl_::Impl_( ::_pbi::ConstantInitialized()), connectionid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR IceCandidate::IceCandidate(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(IceCandidate_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct IceCandidateDefaultTypeInternal { PROTOBUF_CONSTEXPR IceCandidateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~IceCandidateDefaultTypeInternal() {} @@ -292,14 +382,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ExternalFetchDataRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : key_( + : _cached_size_{0}, + key_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ExternalFetchDataRequest::ExternalFetchDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalFetchDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalFetchDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalFetchDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalFetchDataRequestDefaultTypeInternal() {} @@ -313,12 +409,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr DisconnectNotice::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : disconnectmode_{static_cast< ::dht::DisconnectMode >(0)}, - _cached_size_{0} {} + : _cached_size_{0}, + disconnectmode_{static_cast< ::dht::DisconnectMode >(0)} {} template PROTOBUF_CONSTEXPR DisconnectNotice::DisconnectNotice(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(DisconnectNotice_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct DisconnectNoticeDefaultTypeInternal { PROTOBUF_CONSTEXPR DisconnectNoticeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~DisconnectNoticeDefaultTypeInternal() {} @@ -342,7 +444,13 @@ inline constexpr ConnectivityRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ConnectivityRequest::ConnectivityRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityRequestDefaultTypeInternal() {} @@ -356,16 +464,22 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ConnectivityMethod::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : host_( + : _cached_size_{0}, + host_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), port_{0u}, - tls_{false}, - _cached_size_{0} {} + tls_{false} {} template PROTOBUF_CONSTEXPR ConnectivityMethod::ConnectivityMethod(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityMethod_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityMethodDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityMethodDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityMethodDefaultTypeInternal() {} @@ -379,17 +493,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestRingPeersRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : ringid_( + : _cached_size_{0}, + ringid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestRingPeersRequest::ClosestRingPeersRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestRingPeersRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestRingPeersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestRingPeersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestRingPeersRequestDefaultTypeInternal() {} @@ -403,17 +523,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestPeersRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : nodeid_( + : _cached_size_{0}, + nodeid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestPeersRequest::ClosestPeersRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestPeersRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestPeersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestPeersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestPeersRequestDefaultTypeInternal() {} @@ -440,7 +566,13 @@ inline constexpr StoreDataRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR StoreDataRequest::StoreDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(StoreDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct StoreDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR StoreDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StoreDataRequestDefaultTypeInternal() {} @@ -473,7 +605,13 @@ inline constexpr PeerDescriptor::Impl_::Impl_( template PROTOBUF_CONSTEXPR PeerDescriptor::PeerDescriptor(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PeerDescriptor_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PeerDescriptorDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerDescriptorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerDescriptorDefaultTypeInternal() {} @@ -495,7 +633,13 @@ inline constexpr ExternalStoreDataRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ExternalStoreDataRequest::ExternalStoreDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalStoreDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalStoreDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalStoreDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalStoreDataRequestDefaultTypeInternal() {} @@ -525,7 +669,13 @@ inline constexpr DataEntry::Impl_::Impl_( template PROTOBUF_CONSTEXPR DataEntry::DataEntry(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(DataEntry_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct DataEntryDefaultTypeInternal { PROTOBUF_CONSTEXPR DataEntryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~DataEntryDefaultTypeInternal() {} @@ -556,7 +706,13 @@ inline constexpr ConnectivityResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR ConnectivityResponse::ConnectivityResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityResponseDefaultTypeInternal() {} @@ -575,7 +731,13 @@ inline constexpr ReplicateDataRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ReplicateDataRequest::ReplicateDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ReplicateDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ReplicateDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ReplicateDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ReplicateDataRequestDefaultTypeInternal() {} @@ -589,15 +751,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RecursiveOperationResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : closestconnectednodes_{}, + : _cached_size_{0}, + closestconnectednodes_{}, dataentries_{}, routingpath_{}, - noclosernodesfound_{false}, - _cached_size_{0} {} + noclosernodesfound_{false} {} template PROTOBUF_CONSTEXPR RecursiveOperationResponse::RecursiveOperationResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RecursiveOperationResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RecursiveOperationResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR RecursiveOperationResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RecursiveOperationResponseDefaultTypeInternal() {} @@ -620,7 +788,13 @@ inline constexpr HandshakeResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR HandshakeResponse::HandshakeResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HandshakeResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HandshakeResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR HandshakeResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HandshakeResponseDefaultTypeInternal() {} @@ -643,7 +817,13 @@ inline constexpr HandshakeRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR HandshakeRequest::HandshakeRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HandshakeRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HandshakeRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR HandshakeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HandshakeRequestDefaultTypeInternal() {} @@ -657,12 +837,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ExternalStoreDataResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : storers_{}, - _cached_size_{0} {} + : _cached_size_{0}, + storers_{} {} template PROTOBUF_CONSTEXPR ExternalStoreDataResponse::ExternalStoreDataResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalStoreDataResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalStoreDataResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalStoreDataResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalStoreDataResponseDefaultTypeInternal() {} @@ -676,12 +862,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ExternalFetchDataResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : entries_{}, - _cached_size_{0} {} + : _cached_size_{0}, + entries_{} {} template PROTOBUF_CONSTEXPR ExternalFetchDataResponse::ExternalFetchDataResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalFetchDataResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalFetchDataResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalFetchDataResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalFetchDataResponseDefaultTypeInternal() {} @@ -695,16 +887,22 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestRingPeersResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : leftpeers_{}, + : _cached_size_{0}, + leftpeers_{}, rightpeers_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestRingPeersResponse::ClosestRingPeersResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestRingPeersResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestRingPeersResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestRingPeersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestRingPeersResponseDefaultTypeInternal() {} @@ -718,15 +916,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestPeersResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : peers_{}, + : _cached_size_{0}, + peers_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestPeersResponse::ClosestPeersResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestPeersResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestPeersResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestPeersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestPeersResponseDefaultTypeInternal() {} @@ -754,7 +958,13 @@ inline constexpr Message::Impl_::Impl_( template PROTOBUF_CONSTEXPR Message::Message(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(Message_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct MessageDefaultTypeInternal { PROTOBUF_CONSTEXPR MessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MessageDefaultTypeInternal() {} @@ -783,7 +993,13 @@ inline constexpr RouteMessageWrapper::Impl_::Impl_( template PROTOBUF_CONSTEXPR RouteMessageWrapper::RouteMessageWrapper(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RouteMessageWrapper_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RouteMessageWrapperDefaultTypeInternal { PROTOBUF_CONSTEXPR RouteMessageWrapperDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RouteMessageWrapperDefaultTypeInternal() {} @@ -795,491 +1011,343 @@ struct RouteMessageWrapperDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RouteMessageWrapperDefaultTypeInternal _RouteMessageWrapper_default_instance_; } // namespace dht -static ::_pb::Metadata file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[35]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[6]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[6]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto = nullptr; -const ::uint32_t TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _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(::dht::StoreDataRequest, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.data_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.creator_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.createdat_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.ttl_), - ~0u, - 0, - ~0u, - 1, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::StoreDataResponse, _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(::dht::ExternalStoreDataRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _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(::dht::ExternalStoreDataRequest, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_.data_), - ~0u, - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataResponse, _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(::dht::ExternalStoreDataResponse, _impl_.storers_), - PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _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(::dht::ReplicateDataRequest, _impl_.entry_), - 0, - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _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(::dht::DataEntry, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.data_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.creator_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.createdat_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.storedat_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.ttl_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.stale_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.deleted_), - ~0u, - 0, - ~0u, - 1, - 2, - ~0u, - ~0u, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _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(::dht::ClosestPeersRequest, _impl_.nodeid_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _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(::dht::ClosestPeersResponse, _impl_.peers_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _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(::dht::ClosestRingPeersRequest, _impl_.ringid_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _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(::dht::ClosestRingPeersResponse, _impl_.leftpeers_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.rightpeers_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _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(::dht::RecursiveOperationRequest, _impl_.sessionid_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_.operation_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _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(::dht::RecursiveOperationResponse, _impl_.closestconnectednodes_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.dataentries_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.noclosernodesfound_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.routingpath_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::PingRequest, _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(::dht::PingRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::PingResponse, _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(::dht::PingResponse, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::LeaveNotice, _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(::dht::PeerDescriptor, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _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(::dht::PeerDescriptor, _impl_.nodeid_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.type_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.udp_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.tcp_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.websocket_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.region_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.ipaddress_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.publickey_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.signature_), - ~0u, - ~0u, - 2, - 3, - 4, - 5, - 6, - 0, - 1, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _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(::dht::ConnectivityMethod, _impl_.port_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.host_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.tls_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _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(::dht::RouteMessageWrapper, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.sourcepeer_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.target_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.reachablethrough_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.routingpath_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.parallelrootnodeids_), - ~0u, - 0, - ~0u, - 1, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _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(::dht::RouteMessageAck, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_.error_), - ~0u, - 0, - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _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(::dht::ConnectivityRequest, _impl_.port_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.tls_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.host_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.allowselfsignedcertificate_), - ~0u, - ~0u, - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _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(::dht::ConnectivityResponse, _impl_.host_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.nattype_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.websocket_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.ipaddress_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.version_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.latitude_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.longitude_), - ~0u, - ~0u, - 0, - ~0u, - ~0u, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _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(::dht::HandshakeRequest, _impl_.sourcepeerdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.targetpeerdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.version_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _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(::dht::HandshakeResponse, _impl_.sourcepeerdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.error_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.version_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _split_ - ~0u, // no sizeof(Split) - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.messageid_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.sourcedescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.targetdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.serviceid_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), - ~0u, - 0, - 1, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::WebsocketConnectionRequest, _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(::dht::WebrtcConnectionRequest, _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(::dht::RtcOffer, _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(::dht::RtcOffer, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_.connectionid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _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(::dht::RtcAnswer, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_.connectionid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _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(::dht::IceCandidate, _impl_.candidate_), - PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.mid_), - PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.connectionid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::LockRequest, _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(::dht::LockRequest, _impl_.lockid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::UnlockRequest, _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(::dht::UnlockRequest, _impl_.lockid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::LockResponse, _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(::dht::LockResponse, _impl_.accepted_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::DisconnectNotice, _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(::dht::DisconnectNotice, _impl_.disconnectmode_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataRequest, _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(::dht::ExternalFetchDataRequest, _impl_.key_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataResponse, _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(::dht::ExternalFetchDataResponse, _impl_.entries_), +const ::uint32_t + TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_._has_bits_), + 8, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.data_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.creator_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.createdat_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.ttl_), + 0, + 2, + 1, + 3, + 4, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_.data_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataResponse, _impl_.storers_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _impl_.entry_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_._has_bits_), + 11, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.data_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.creator_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.createdat_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.storedat_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.ttl_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.stale_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.deleted_), + 0, + 2, + 1, + 3, + 4, + 5, + 6, + 7, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_.nodeid_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_.peers_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_.ringid_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.leftpeers_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.rightpeers_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.requestid_), + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_.sessionid_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_.operation_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.closestconnectednodes_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.dataentries_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.noclosernodesfound_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.routingpath_), + 0, + 1, + 3, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::PingRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::PingRequest, _impl_.requestid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::PingResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::PingResponse, _impl_.requestid_), + 0, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_._has_bits_), + 12, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.nodeid_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.udp_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.tcp_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.websocket_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.region_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.ipaddress_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.publickey_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.signature_), + 0, + 6, + 3, + 4, + 5, + 7, + 8, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.tls_), + 1, + 0, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.sourcepeer_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.target_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.reachablethrough_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.routingpath_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.parallelrootnodeids_), + 3, + 5, + 4, + 6, + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_.error_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.tls_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.allowselfsignedcertificate_), + 1, + 2, + 0, + 3, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.nattype_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.websocket_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.ipaddress_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.version_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.latitude_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.longitude_), + 0, + 1, + 3, + 6, + 2, + 4, + 5, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.sourcepeerdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.targetpeerdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.version_), + 1, + 2, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.sourcepeerdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.version_), + 1, + 2, + 0, + 0x085, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_[0]), + 15, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.messageid_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.sourcedescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.targetdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.serviceid_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + 0, + 2, + 3, + 1, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 0x000, // bitmap + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_.connectionid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_.connectionid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.candidate_), + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.mid_), + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.connectionid_), + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::LockRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::LockRequest, _impl_.lockid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::UnlockRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::UnlockRequest, _impl_.lockid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::LockResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::LockResponse, _impl_.accepted_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::DisconnectNotice, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::DisconnectNotice, _impl_.disconnectmode_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataRequest, _impl_.key_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataResponse, _impl_.entries_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 13, -1, sizeof(::dht::StoreDataRequest)}, - {18, -1, -1, sizeof(::dht::StoreDataResponse)}, - {26, 36, -1, sizeof(::dht::ExternalStoreDataRequest)}, - {38, -1, -1, sizeof(::dht::ExternalStoreDataResponse)}, - {47, 56, -1, sizeof(::dht::ReplicateDataRequest)}, - {57, 73, -1, sizeof(::dht::DataEntry)}, - {81, -1, -1, sizeof(::dht::ClosestPeersRequest)}, - {91, -1, -1, sizeof(::dht::ClosestPeersResponse)}, - {101, -1, -1, sizeof(::dht::ClosestRingPeersRequest)}, - {111, -1, -1, sizeof(::dht::ClosestRingPeersResponse)}, - {122, -1, -1, sizeof(::dht::RecursiveOperationRequest)}, - {132, -1, -1, sizeof(::dht::RecursiveOperationResponse)}, - {144, -1, -1, sizeof(::dht::PingRequest)}, - {153, -1, -1, sizeof(::dht::PingResponse)}, - {162, -1, -1, sizeof(::dht::LeaveNotice)}, - {170, 187, -1, sizeof(::dht::PeerDescriptor)}, - {196, -1, -1, sizeof(::dht::ConnectivityMethod)}, - {207, 222, -1, sizeof(::dht::RouteMessageWrapper)}, - {229, 239, -1, sizeof(::dht::RouteMessageAck)}, - {241, 253, -1, sizeof(::dht::ConnectivityRequest)}, - {257, 272, -1, sizeof(::dht::ConnectivityResponse)}, - {279, 290, -1, sizeof(::dht::HandshakeRequest)}, - {293, 304, -1, sizeof(::dht::HandshakeResponse)}, - {307, 326, -1, sizeof(::dht::Message)}, - {336, -1, -1, sizeof(::dht::WebsocketConnectionRequest)}, - {344, -1, -1, sizeof(::dht::WebrtcConnectionRequest)}, - {352, -1, -1, sizeof(::dht::RtcOffer)}, - {362, -1, -1, sizeof(::dht::RtcAnswer)}, - {372, -1, -1, sizeof(::dht::IceCandidate)}, - {383, -1, -1, sizeof(::dht::LockRequest)}, - {392, -1, -1, sizeof(::dht::UnlockRequest)}, - {401, -1, -1, sizeof(::dht::LockResponse)}, - {410, -1, -1, sizeof(::dht::DisconnectNotice)}, - {419, -1, -1, sizeof(::dht::ExternalFetchDataRequest)}, - {428, -1, -1, sizeof(::dht::ExternalFetchDataResponse)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::dht::StoreDataRequest)}, + {13, sizeof(::dht::StoreDataResponse)}, + {14, sizeof(::dht::ExternalStoreDataRequest)}, + {21, sizeof(::dht::ExternalStoreDataResponse)}, + {26, sizeof(::dht::ReplicateDataRequest)}, + {31, sizeof(::dht::DataEntry)}, + {50, sizeof(::dht::ClosestPeersRequest)}, + {57, sizeof(::dht::ClosestPeersResponse)}, + {64, sizeof(::dht::ClosestRingPeersRequest)}, + {71, sizeof(::dht::ClosestRingPeersResponse)}, + {80, sizeof(::dht::RecursiveOperationRequest)}, + {87, sizeof(::dht::RecursiveOperationResponse)}, + {98, sizeof(::dht::PingRequest)}, + {103, sizeof(::dht::PingResponse)}, + {108, sizeof(::dht::LeaveNotice)}, + {109, sizeof(::dht::PeerDescriptor)}, + {130, sizeof(::dht::ConnectivityMethod)}, + {139, sizeof(::dht::RouteMessageWrapper)}, + {156, sizeof(::dht::RouteMessageAck)}, + {163, sizeof(::dht::ConnectivityRequest)}, + {174, sizeof(::dht::ConnectivityResponse)}, + {191, sizeof(::dht::HandshakeRequest)}, + {200, sizeof(::dht::HandshakeResponse)}, + {209, sizeof(::dht::Message)}, + {234, sizeof(::dht::WebsocketConnectionRequest)}, + {235, sizeof(::dht::WebrtcConnectionRequest)}, + {236, sizeof(::dht::RtcOffer)}, + {243, sizeof(::dht::RtcAnswer)}, + {250, sizeof(::dht::IceCandidate)}, + {259, sizeof(::dht::LockRequest)}, + {264, sizeof(::dht::UnlockRequest)}, + {269, sizeof(::dht::LockResponse)}, + {274, sizeof(::dht::DisconnectNotice)}, + {279, sizeof(::dht::ExternalFetchDataRequest)}, + {284, sizeof(::dht::ExternalFetchDataResponse)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::dht::_StoreDataRequest_default_instance_._instance, &::dht::_StoreDataResponse_default_instance_._instance, &::dht::_ExternalStoreDataRequest_default_instance_._instance, @@ -1316,7 +1384,8 @@ static const ::_pb::Message* const file_default_instances[] = { &::dht::_ExternalFetchDataRequest_default_instance_._instance, &::dht::_ExternalFetchDataResponse_default_instance_._instance, }; -const char descriptor_table_protodef_packages_2fdht_2fprotos_2fDhtRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_packages_2fdht_2fprotos_2fDhtRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n packages/dht/protos/DhtRpc.proto\022\003dht\032" "\033google/protobuf/empty.proto\032\031google/pro" "tobuf/any.proto\032\037google/protobuf/timesta" @@ -1463,15 +1532,15 @@ const char descriptor_table_protodef_packages_2fdht_2fprotos_2fDhtRpc_2eproto[] "dht.ExternalStoreDataResponseB\002H\002b\006proto" "3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_deps[4] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_deps[4] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_google_2fprotobuf_2ftimestamp_2eproto, &::descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, }; static ::absl::once_flag descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto = { false, false, 5761, @@ -1484,159 +1553,120 @@ const ::_pbi::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_ schemas, file_default_instances, TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto::offsets, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto, file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto, file_level_service_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter() { - return &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_packages_2fdht_2fprotos_2fDhtRpc_2eproto(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); namespace dht { -const ::google::protobuf::EnumDescriptor* RecursiveOperation_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RecursiveOperation_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t RecursiveOperation_internal_data_[] = { 196608u, 0u, }; -bool RecursiveOperation_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* NodeType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL NodeType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[1]; } PROTOBUF_CONSTINIT const uint32_t NodeType_internal_data_[] = { 131072u, 0u, }; -bool NodeType_IsValid(int value) { - return 0 <= value && value <= 1; -} -const ::google::protobuf::EnumDescriptor* RpcResponseError_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcResponseError_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[2]; } PROTOBUF_CONSTINIT const uint32_t RpcResponseError_internal_data_[] = { 262144u, 0u, }; -bool RpcResponseError_IsValid(int value) { - return 0 <= value && value <= 3; -} -const ::google::protobuf::EnumDescriptor* RouteMessageError_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RouteMessageError_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[3]; } PROTOBUF_CONSTINIT const uint32_t RouteMessageError_internal_data_[] = { 196608u, 0u, }; -bool RouteMessageError_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* HandshakeError_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL HandshakeError_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[4]; } PROTOBUF_CONSTINIT const uint32_t HandshakeError_internal_data_[] = { 196608u, 0u, }; -bool HandshakeError_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* DisconnectMode_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DisconnectMode_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[5]; } PROTOBUF_CONSTINIT const uint32_t DisconnectMode_internal_data_[] = { 131072u, 0u, }; -bool DisconnectMode_IsValid(int value) { - return 0 <= value && value <= 1; -} // =================================================================== class StoreDataRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_._has_bits_); - static const ::google::protobuf::Any& data(const StoreDataRequest* msg); - static void set_has_data(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::google::protobuf::Timestamp& createdat(const StoreDataRequest* msg); - static void set_has_createdat(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_._has_bits_); }; -const ::google::protobuf::Any& StoreDataRequest::_Internal::data(const StoreDataRequest* msg) { - return *msg->_impl_.data_; -} -const ::google::protobuf::Timestamp& StoreDataRequest::_Internal::createdat(const StoreDataRequest* msg) { - return *msg->_impl_.createdat_; -} void StoreDataRequest::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } void StoreDataRequest::clear_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ != nullptr) _impl_.createdat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -StoreDataRequest::StoreDataRequest(::google::protobuf::Arena* arena) +StoreDataRequest::StoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.StoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::StoreDataRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, key_(arena, from.key_), creator_(arena, from.creator_) {} StoreDataRequest::StoreDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StoreDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.data_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.data_) + _impl_.data_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.data_) : nullptr; - _impl_.createdat_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.createdat_) + _impl_.createdat_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.createdat_) : nullptr; _impl_.ttl_ = from._impl_.ttl_; // @@protoc_insertion_point(copy_constructor:dht.StoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, key_(arena), creator_(arena) {} -inline void StoreDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void StoreDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, ttl_) - @@ -1645,29 +1675,135 @@ inline void StoreDataRequest::SharedCtor(::_pb::Arena* arena) { } StoreDataRequest::~StoreDataRequest() { // @@protoc_insertion_point(destructor:dht.StoreDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void StoreDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - _impl_.creator_.Destroy(); - delete _impl_.data_; - delete _impl_.createdat_; - _impl_.~Impl_(); +inline void StoreDataRequest::SharedDtor(MessageLite& self) { + StoreDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + this_._impl_.creator_.Destroy(); + delete this_._impl_.data_; + delete this_._impl_.createdat_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL StoreDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StoreDataRequest(arena); +} +constexpr auto StoreDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(StoreDataRequest), + alignof(StoreDataRequest)); +} +constexpr auto StoreDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StoreDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StoreDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StoreDataRequest::SharedDtor, + static_cast(&StoreDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_._cached_size_), + false, + }, + &StoreDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* StoreDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void StoreDataRequest::InternalSwap(StoreDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StoreDataRequest_class_data_ = + StoreDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StoreDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StoreDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StoreDataRequest_class_data_.tc_table); + return StoreDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 2, 0, 2> +StoreDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _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), + StoreDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::StoreDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.key_)}}, + // .google.protobuf.Any data = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.data_)}}, + // bytes creator = 3; + {::_pbi::TcParser::FastBS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.creator_)}}, + // .google.protobuf.Timestamp createdAt = 4; + {::_pbi::TcParser::FastMtS1, + {34, 3, 1, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.createdat_)}}, + // uint32 ttl = 5; + {::_pbi::TcParser::FastV32S1, + {40, 4, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.ttl_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Any data = 2; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.data_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes creator = 3; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.creator_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Timestamp createdAt = 4; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.createdat_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 ttl = 5; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.ttl_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()}, + }}, + {{ + }}, +}; +void StoreDataRequest::InternalSwap(StoreDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata StoreDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -1675,14 +1811,22 @@ class StoreDataResponse::_Internal { public: }; -StoreDataResponse::StoreDataResponse(::google::protobuf::Arena* arena) +StoreDataResponse::StoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, StoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.StoreDataResponse) } StoreDataResponse::StoreDataResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, StoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StoreDataResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -1691,310 +1835,643 @@ StoreDataResponse::StoreDataResponse( // @@protoc_insertion_point(copy_constructor:dht.StoreDataResponse) } +inline void* PROTOBUF_NONNULL StoreDataResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StoreDataResponse(arena); +} +constexpr auto StoreDataResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(StoreDataResponse), + alignof(StoreDataResponse)); +} +constexpr auto StoreDataResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StoreDataResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StoreDataResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StoreDataResponse::SharedDtor, + static_cast(&StoreDataResponse::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StoreDataResponse, _impl_._cached_size_), + false, + }, + &StoreDataResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StoreDataResponse_class_data_ = + StoreDataResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StoreDataResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StoreDataResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StoreDataResponse_class_data_.tc_table); + return StoreDataResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +StoreDataResponse::_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 + StoreDataResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::StoreDataResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata StoreDataResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[1]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalStoreDataRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._has_bits_); - static const ::google::protobuf::Any& data(const ExternalStoreDataRequest* msg); - static void set_has_data(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._has_bits_); }; -const ::google::protobuf::Any& ExternalStoreDataRequest::_Internal::data(const ExternalStoreDataRequest* msg) { - return *msg->_impl_.data_; -} void ExternalStoreDataRequest::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -ExternalStoreDataRequest::ExternalStoreDataRequest(::google::protobuf::Arena* arena) +ExternalStoreDataRequest::ExternalStoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalStoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalStoreDataRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, key_(arena, from.key_) {} ExternalStoreDataRequest::ExternalStoreDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalStoreDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.data_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.data_) + _impl_.data_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.data_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.ExternalStoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, key_(arena) {} -inline void ExternalStoreDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void ExternalStoreDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.data_ = {}; } ExternalStoreDataRequest::~ExternalStoreDataRequest() { // @@protoc_insertion_point(destructor:dht.ExternalStoreDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalStoreDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - delete _impl_.data_; - _impl_.~Impl_(); +inline void ExternalStoreDataRequest::SharedDtor(MessageLite& self) { + ExternalStoreDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + delete this_._impl_.data_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalStoreDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalStoreDataRequest(arena); +} +constexpr auto ExternalStoreDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ExternalStoreDataRequest), + alignof(ExternalStoreDataRequest)); +} +constexpr auto ExternalStoreDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalStoreDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalStoreDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalStoreDataRequest::SharedDtor, + static_cast(&ExternalStoreDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._cached_size_), + false, + }, + &ExternalStoreDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ExternalStoreDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ExternalStoreDataRequest::InternalSwap(ExternalStoreDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalStoreDataRequest_class_data_ = + ExternalStoreDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalStoreDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalStoreDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalStoreDataRequest_class_data_.tc_table); + return ExternalStoreDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> +ExternalStoreDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._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), + ExternalStoreDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalStoreDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .google.protobuf.Any data = 2; + {::_pbi::TcParser::FastMtS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.data_)}}, + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Any data = 2; + {PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.data_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + }}, + {{ + }}, +}; +void ExternalStoreDataRequest::InternalSwap(ExternalStoreDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalStoreDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalStoreDataResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_._has_bits_); }; -ExternalStoreDataResponse::ExternalStoreDataResponse(::google::protobuf::Arena* arena) +ExternalStoreDataResponse::ExternalStoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalStoreDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : storers_{visibility, arena, from.storers_}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalStoreDataResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + storers_{visibility, arena, from.storers_} {} ExternalStoreDataResponse::ExternalStoreDataResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalStoreDataResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ExternalStoreDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : storers_{visibility, arena}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + storers_{visibility, arena} {} -inline void ExternalStoreDataResponse::SharedCtor(::_pb::Arena* arena) { +inline void ExternalStoreDataResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExternalStoreDataResponse::~ExternalStoreDataResponse() { // @@protoc_insertion_point(destructor:dht.ExternalStoreDataResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalStoreDataResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void ExternalStoreDataResponse::SharedDtor(MessageLite& self) { + ExternalStoreDataResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalStoreDataResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalStoreDataResponse(arena); +} +constexpr auto ExternalStoreDataResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_.storers_) + + decltype(ExternalStoreDataResponse::_impl_.storers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(ExternalStoreDataResponse), alignof(ExternalStoreDataResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ExternalStoreDataResponse::PlacementNew_, + sizeof(ExternalStoreDataResponse), + alignof(ExternalStoreDataResponse)); + } } - -::_pbi::CachedSize* ExternalStoreDataResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ExternalStoreDataResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalStoreDataResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalStoreDataResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalStoreDataResponse::SharedDtor, + static_cast(&ExternalStoreDataResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_._cached_size_), + false, + }, + &ExternalStoreDataResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ExternalStoreDataResponse::InternalSwap(ExternalStoreDataResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalStoreDataResponse_class_data_ = + ExternalStoreDataResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalStoreDataResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalStoreDataResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalStoreDataResponse_class_data_.tc_table); + return ExternalStoreDataResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +ExternalStoreDataResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _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), + ExternalStoreDataResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalStoreDataResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.PeerDescriptor storers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_.storers_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor storers = 1; + {PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_.storers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + }}, +}; +void ExternalStoreDataResponse::InternalSwap(ExternalStoreDataResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalStoreDataResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[3]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ReplicateDataRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_._has_bits_); - static const ::dht::DataEntry& entry(const ReplicateDataRequest* msg); - static void set_has_entry(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_._has_bits_); }; -const ::dht::DataEntry& ReplicateDataRequest::_Internal::entry(const ReplicateDataRequest* msg) { - return *msg->_impl_.entry_; -} -ReplicateDataRequest::ReplicateDataRequest(::google::protobuf::Arena* arena) +ReplicateDataRequest::ReplicateDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ReplicateDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ReplicateDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ReplicateDataRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} ReplicateDataRequest::ReplicateDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ReplicateDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ReplicateDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ReplicateDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.entry_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::DataEntry>(arena, *from._impl_.entry_) + _impl_.entry_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.entry_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.ReplicateDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void ReplicateDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void ReplicateDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.entry_ = {}; } ReplicateDataRequest::~ReplicateDataRequest() { // @@protoc_insertion_point(destructor:dht.ReplicateDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ReplicateDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - delete _impl_.entry_; - _impl_.~Impl_(); +inline void ReplicateDataRequest::SharedDtor(MessageLite& self) { + ReplicateDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.entry_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ReplicateDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ReplicateDataRequest(arena); +} +constexpr auto ReplicateDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ReplicateDataRequest), + alignof(ReplicateDataRequest)); +} +constexpr auto ReplicateDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ReplicateDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ReplicateDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ReplicateDataRequest::SharedDtor, + static_cast(&ReplicateDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_._cached_size_), + false, + }, + &ReplicateDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ReplicateDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ReplicateDataRequest::InternalSwap(ReplicateDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ReplicateDataRequest_class_data_ = + ReplicateDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ReplicateDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ReplicateDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ReplicateDataRequest_class_data_.tc_table); + return ReplicateDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +ReplicateDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _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), + ReplicateDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ReplicateDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.DataEntry entry = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_.entry_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.DataEntry entry = 1; + {PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_.entry_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::DataEntry>()}, + }}, + {{ + }}, +}; +void ReplicateDataRequest::InternalSwap(ReplicateDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ReplicateDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[4]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class DataEntry::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._has_bits_); - static const ::google::protobuf::Any& data(const DataEntry* msg); - static void set_has_data(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::google::protobuf::Timestamp& createdat(const DataEntry* msg); - static void set_has_createdat(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::google::protobuf::Timestamp& storedat(const DataEntry* msg); - static void set_has_storedat(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._has_bits_); }; -const ::google::protobuf::Any& DataEntry::_Internal::data(const DataEntry* msg) { - return *msg->_impl_.data_; -} -const ::google::protobuf::Timestamp& DataEntry::_Internal::createdat(const DataEntry* msg) { - return *msg->_impl_.createdat_; -} -const ::google::protobuf::Timestamp& DataEntry::_Internal::storedat(const DataEntry* msg) { - return *msg->_impl_.storedat_; -} void DataEntry::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } void DataEntry::clear_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ != nullptr) _impl_.createdat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } void DataEntry::clear_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.storedat_ != nullptr) _impl_.storedat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -DataEntry::DataEntry(::google::protobuf::Arena* arena) +DataEntry::DataEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DataEntry_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.DataEntry) } -inline PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::DataEntry& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, key_(arena, from.key_), creator_(arena, from.creator_) {} DataEntry::DataEntry( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DataEntry& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DataEntry_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE DataEntry* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.data_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.data_) + _impl_.data_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.data_) : nullptr; - _impl_.createdat_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.createdat_) + _impl_.createdat_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.createdat_) : nullptr; - _impl_.storedat_ = (cached_has_bits & 0x00000004u) - ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.storedat_) + _impl_.storedat_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.storedat_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, ttl_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, ttl_), offsetof(Impl_, deleted_) - offsetof(Impl_, ttl_) + @@ -2002,16 +2479,16 @@ DataEntry::DataEntry( // @@protoc_insertion_point(copy_constructor:dht.DataEntry) } -inline PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, key_(arena), creator_(arena) {} -inline void DataEntry::SharedCtor(::_pb::Arena* arena) { +inline void DataEntry::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, deleted_) - @@ -2020,537 +2497,1512 @@ inline void DataEntry::SharedCtor(::_pb::Arena* arena) { } DataEntry::~DataEntry() { // @@protoc_insertion_point(destructor:dht.DataEntry) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void DataEntry::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - _impl_.creator_.Destroy(); - delete _impl_.data_; - delete _impl_.createdat_; - delete _impl_.storedat_; - _impl_.~Impl_(); +inline void DataEntry::SharedDtor(MessageLite& self) { + DataEntry& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + this_._impl_.creator_.Destroy(); + delete this_._impl_.data_; + delete this_._impl_.createdat_; + delete this_._impl_.storedat_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL DataEntry::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) DataEntry(arena); +} +constexpr auto DataEntry::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(DataEntry), + alignof(DataEntry)); +} +constexpr auto DataEntry::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_DataEntry_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DataEntry::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DataEntry::SharedDtor, + static_cast(&DataEntry::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._cached_size_), + false, + }, + &DataEntry::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* DataEntry::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void DataEntry::InternalSwap(DataEntry* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull DataEntry_class_data_ = + DataEntry::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +DataEntry::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&DataEntry_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(DataEntry_class_data_.tc_table); + return DataEntry_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 8, 3, 0, 2> +DataEntry::_table_ = { + { + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + DataEntry_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::DataEntry>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool deleted = 8; + {::_pbi::TcParser::FastV8S1, + {64, 7, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.deleted_)}}, + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.key_)}}, + // .google.protobuf.Any data = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.data_)}}, + // bytes creator = 3; + {::_pbi::TcParser::FastBS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.creator_)}}, + // .google.protobuf.Timestamp createdAt = 4; + {::_pbi::TcParser::FastMtS1, + {34, 3, 1, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.createdat_)}}, + // .google.protobuf.Timestamp storedAt = 5; + {::_pbi::TcParser::FastMtS1, + {42, 4, 2, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.storedat_)}}, + // uint32 ttl = 6; + {::_pbi::TcParser::FastV32S1, + {48, 5, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.ttl_)}}, + // bool stale = 7; + {::_pbi::TcParser::FastV8S1, + {56, 6, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.stale_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Any data = 2; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.data_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes creator = 3; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.creator_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Timestamp createdAt = 4; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.createdat_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .google.protobuf.Timestamp storedAt = 5; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.storedat_), _Internal::kHasBitsOffset + 4, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 ttl = 6; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.ttl_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // bool stale = 7; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.stale_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // bool deleted = 8; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.deleted_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()}, + }}, + {{ + }}, +}; +void DataEntry::InternalSwap(DataEntry* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata DataEntry::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[5]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestPeersRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._has_bits_); }; -ClosestPeersRequest::ClosestPeersRequest(::google::protobuf::Arena* arena) +ClosestPeersRequest::ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : nodeid_(arena, from.nodeid_), - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestPeersRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + nodeid_(arena, from.nodeid_), + requestid_(arena, from.requestid_) {} ClosestPeersRequest::ClosestPeersRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestPeersRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : nodeid_(arena), - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + nodeid_(arena), + requestid_(arena) {} -inline void ClosestPeersRequest::SharedCtor(::_pb::Arena* arena) { +inline void ClosestPeersRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestPeersRequest::~ClosestPeersRequest() { // @@protoc_insertion_point(destructor:dht.ClosestPeersRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestPeersRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.nodeid_.Destroy(); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestPeersRequest::SharedDtor(MessageLite& self) { + ClosestPeersRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.nodeid_.Destroy(); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestPeersRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestPeersRequest(arena); +} +constexpr auto ClosestPeersRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClosestPeersRequest), + alignof(ClosestPeersRequest)); +} +constexpr auto ClosestPeersRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestPeersRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestPeersRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestPeersRequest::SharedDtor, + static_cast(&ClosestPeersRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._cached_size_), + false, + }, + &ClosestPeersRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ClosestPeersRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ClosestPeersRequest::InternalSwap(ClosestPeersRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_ = + ClosestPeersRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestPeersRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestPeersRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestPeersRequest_class_data_.tc_table); + return ClosestPeersRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 41, 2> +ClosestPeersRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._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 + ClosestPeersRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestPeersRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.requestid_)}}, + // bytes nodeId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.nodeid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes nodeId = 1; + {PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.nodeid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\27\0\11\0\0\0\0\0" + "dht.ClosestPeersRequest" + "requestId" + }}, +}; +void ClosestPeersRequest::InternalSwap(ClosestPeersRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestPeersRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[6]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestPeersResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._has_bits_); }; -ClosestPeersResponse::ClosestPeersResponse(::google::protobuf::Arena* arena) +ClosestPeersResponse::ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : peers_{visibility, arena, from.peers_}, - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestPeersResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + peers_{visibility, arena, from.peers_}, + requestid_(arena, from.requestid_) {} ClosestPeersResponse::ClosestPeersResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestPeersResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : peers_{visibility, arena}, - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + peers_{visibility, arena}, + requestid_(arena) {} -inline void ClosestPeersResponse::SharedCtor(::_pb::Arena* arena) { +inline void ClosestPeersResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestPeersResponse::~ClosestPeersResponse() { // @@protoc_insertion_point(destructor:dht.ClosestPeersResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestPeersResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestPeersResponse::SharedDtor(MessageLite& self) { + ClosestPeersResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestPeersResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestPeersResponse(arena); +} +constexpr auto ClosestPeersResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_) + + decltype(ClosestPeersResponse::_impl_.peers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(ClosestPeersResponse), alignof(ClosestPeersResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ClosestPeersResponse::PlacementNew_, + sizeof(ClosestPeersResponse), + alignof(ClosestPeersResponse)); + } } - -::_pbi::CachedSize* ClosestPeersResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ClosestPeersResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestPeersResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestPeersResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestPeersResponse::SharedDtor, + static_cast(&ClosestPeersResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._cached_size_), + false, + }, + &ClosestPeersResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ClosestPeersResponse::InternalSwap(ClosestPeersResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_ = + ClosestPeersResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestPeersResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestPeersResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestPeersResponse_class_data_.tc_table); + return ClosestPeersResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 42, 2> +ClosestPeersResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._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), + ClosestPeersResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestPeersResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.requestid_)}}, + // repeated .dht.PeerDescriptor peers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor peers = 1; + {PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\30\0\11\0\0\0\0\0" + "dht.ClosestPeersResponse" + "requestId" + }}, +}; +void ClosestPeersResponse::InternalSwap(ClosestPeersResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestPeersResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[7]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestRingPeersRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_._has_bits_); }; -ClosestRingPeersRequest::ClosestRingPeersRequest(::google::protobuf::Arena* arena) +ClosestRingPeersRequest::ClosestRingPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestRingPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : ringid_(arena, from.ringid_), - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestRingPeersRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + ringid_(arena, from.ringid_), + requestid_(arena, from.requestid_) {} ClosestRingPeersRequest::ClosestRingPeersRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestRingPeersRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestRingPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : ringid_(arena), - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + ringid_(arena), + requestid_(arena) {} -inline void ClosestRingPeersRequest::SharedCtor(::_pb::Arena* arena) { +inline void ClosestRingPeersRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestRingPeersRequest::~ClosestRingPeersRequest() { // @@protoc_insertion_point(destructor:dht.ClosestRingPeersRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestRingPeersRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.ringid_.Destroy(); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestRingPeersRequest::SharedDtor(MessageLite& self) { + ClosestRingPeersRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.ringid_.Destroy(); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestRingPeersRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestRingPeersRequest(arena); +} +constexpr auto ClosestRingPeersRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClosestRingPeersRequest), + alignof(ClosestRingPeersRequest)); +} +constexpr auto ClosestRingPeersRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestRingPeersRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestRingPeersRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestRingPeersRequest::SharedDtor, + static_cast(&ClosestRingPeersRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_._cached_size_), + false, + }, + &ClosestRingPeersRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ClosestRingPeersRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ClosestRingPeersRequest::InternalSwap(ClosestRingPeersRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestRingPeersRequest_class_data_ = + ClosestRingPeersRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestRingPeersRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestRingPeersRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestRingPeersRequest_class_data_.tc_table); + return ClosestRingPeersRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 45, 2> +ClosestRingPeersRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_._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 + ClosestRingPeersRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestRingPeersRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.requestid_)}}, + // bytes ringId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.ringid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes ringId = 1; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.ringid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\33\0\11\0\0\0\0\0" + "dht.ClosestRingPeersRequest" + "requestId" + }}, +}; +void ClosestRingPeersRequest::InternalSwap(ClosestRingPeersRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestRingPeersRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[8]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestRingPeersResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_._has_bits_); }; -ClosestRingPeersResponse::ClosestRingPeersResponse(::google::protobuf::Arena* arena) +ClosestRingPeersResponse::ClosestRingPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestRingPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : leftpeers_{visibility, arena, from.leftpeers_}, +PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestRingPeersResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + leftpeers_{visibility, arena, from.leftpeers_}, rightpeers_{visibility, arena, from.rightpeers_}, - requestid_(arena, from.requestid_), - _cached_size_{0} {} + requestid_(arena, from.requestid_) {} ClosestRingPeersResponse::ClosestRingPeersResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestRingPeersResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestRingPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : leftpeers_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + leftpeers_{visibility, arena}, rightpeers_{visibility, arena}, - requestid_(arena), - _cached_size_{0} {} + requestid_(arena) {} -inline void ClosestRingPeersResponse::SharedCtor(::_pb::Arena* arena) { +inline void ClosestRingPeersResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestRingPeersResponse::~ClosestRingPeersResponse() { // @@protoc_insertion_point(destructor:dht.ClosestRingPeersResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestRingPeersResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestRingPeersResponse::SharedDtor(MessageLite& self) { + ClosestRingPeersResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestRingPeersResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestRingPeersResponse(arena); +} +constexpr auto ClosestRingPeersResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.leftpeers_) + + decltype(ClosestRingPeersResponse::_impl_.leftpeers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.rightpeers_) + + decltype(ClosestRingPeersResponse::_impl_.rightpeers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(ClosestRingPeersResponse), alignof(ClosestRingPeersResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ClosestRingPeersResponse::PlacementNew_, + sizeof(ClosestRingPeersResponse), + alignof(ClosestRingPeersResponse)); + } } - -::_pbi::CachedSize* ClosestRingPeersResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ClosestRingPeersResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestRingPeersResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestRingPeersResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestRingPeersResponse::SharedDtor, + static_cast(&ClosestRingPeersResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_._cached_size_), + false, + }, + &ClosestRingPeersResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ClosestRingPeersResponse::InternalSwap(ClosestRingPeersResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestRingPeersResponse_class_data_ = + ClosestRingPeersResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestRingPeersResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestRingPeersResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestRingPeersResponse_class_data_.tc_table); + return ClosestRingPeersResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 46, 2> +ClosestRingPeersResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + ClosestRingPeersResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestRingPeersResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // repeated .dht.PeerDescriptor leftPeers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.leftpeers_)}}, + // repeated .dht.PeerDescriptor rightPeers = 2; + {::_pbi::TcParser::FastMtR1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.rightpeers_)}}, + // string requestId = 3; + {::_pbi::TcParser::FastUS1, + {26, 2, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor leftPeers = 1; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.leftpeers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor rightPeers = 2; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.rightpeers_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 3; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\34\0\0\11\0\0\0\0" + "dht.ClosestRingPeersResponse" + "requestId" + }}, +}; +void ClosestRingPeersResponse::InternalSwap(ClosestRingPeersResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestRingPeersResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[9]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RecursiveOperationRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_._has_bits_); }; -RecursiveOperationRequest::RecursiveOperationRequest(::google::protobuf::Arena* arena) +RecursiveOperationRequest::RecursiveOperationRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RecursiveOperationRequest) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : sessionid_(arena, from.sessionid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RecursiveOperationRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + sessionid_(arena, from.sessionid_) {} RecursiveOperationRequest::RecursiveOperationRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RecursiveOperationRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.operation_ = from._impl_.operation_; // @@protoc_insertion_point(copy_constructor:dht.RecursiveOperationRequest) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : sessionid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + sessionid_(arena) {} -inline void RecursiveOperationRequest::SharedCtor(::_pb::Arena* arena) { +inline void RecursiveOperationRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.operation_ = {}; } RecursiveOperationRequest::~RecursiveOperationRequest() { // @@protoc_insertion_point(destructor:dht.RecursiveOperationRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RecursiveOperationRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.sessionid_.Destroy(); - _impl_.~Impl_(); +inline void RecursiveOperationRequest::SharedDtor(MessageLite& self) { + RecursiveOperationRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.sessionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RecursiveOperationRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RecursiveOperationRequest(arena); +} +constexpr auto RecursiveOperationRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RecursiveOperationRequest), + alignof(RecursiveOperationRequest)); +} +constexpr auto RecursiveOperationRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RecursiveOperationRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RecursiveOperationRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RecursiveOperationRequest::SharedDtor, + static_cast(&RecursiveOperationRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_._cached_size_), + false, + }, + &RecursiveOperationRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RecursiveOperationRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RecursiveOperationRequest::InternalSwap(RecursiveOperationRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RecursiveOperationRequest_class_data_ = + RecursiveOperationRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RecursiveOperationRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RecursiveOperationRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RecursiveOperationRequest_class_data_.tc_table); + return RecursiveOperationRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 47, 2> +RecursiveOperationRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_._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 + RecursiveOperationRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RecursiveOperationRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.RecursiveOperation operation = 2; + {::_pbi::TcParser::FastV32S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.operation_)}}, + // string sessionId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.sessionid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string sessionId = 1; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.sessionid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.RecursiveOperation operation = 2; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.operation_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + "\35\11\0\0\0\0\0\0" + "dht.RecursiveOperationRequest" + "sessionId" + }}, +}; +void RecursiveOperationRequest::InternalSwap(RecursiveOperationRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RecursiveOperationRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[10]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RecursiveOperationResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_._has_bits_); }; -RecursiveOperationResponse::RecursiveOperationResponse(::google::protobuf::Arena* arena) +RecursiveOperationResponse::RecursiveOperationResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RecursiveOperationResponse) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : closestconnectednodes_{visibility, arena, from.closestconnectednodes_}, +PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RecursiveOperationResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + closestconnectednodes_{visibility, arena, from.closestconnectednodes_}, dataentries_{visibility, arena, from.dataentries_}, - routingpath_{visibility, arena, from.routingpath_}, - _cached_size_{0} {} + routingpath_{visibility, arena, from.routingpath_} {} RecursiveOperationResponse::RecursiveOperationResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RecursiveOperationResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.noclosernodesfound_ = from._impl_.noclosernodesfound_; // @@protoc_insertion_point(copy_constructor:dht.RecursiveOperationResponse) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : closestconnectednodes_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + closestconnectednodes_{visibility, arena}, dataentries_{visibility, arena}, - routingpath_{visibility, arena}, - _cached_size_{0} {} + routingpath_{visibility, arena} {} -inline void RecursiveOperationResponse::SharedCtor(::_pb::Arena* arena) { +inline void RecursiveOperationResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.noclosernodesfound_ = {}; } RecursiveOperationResponse::~RecursiveOperationResponse() { // @@protoc_insertion_point(destructor:dht.RecursiveOperationResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RecursiveOperationResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void RecursiveOperationResponse::SharedDtor(MessageLite& self) { + RecursiveOperationResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RecursiveOperationResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RecursiveOperationResponse(arena); +} +constexpr auto RecursiveOperationResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.closestconnectednodes_) + + decltype(RecursiveOperationResponse::_impl_.closestconnectednodes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.dataentries_) + + decltype(RecursiveOperationResponse::_impl_.dataentries_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.routingpath_) + + decltype(RecursiveOperationResponse::_impl_.routingpath_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(RecursiveOperationResponse), alignof(RecursiveOperationResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RecursiveOperationResponse::PlacementNew_, + sizeof(RecursiveOperationResponse), + alignof(RecursiveOperationResponse)); + } } - -::_pbi::CachedSize* RecursiveOperationResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto RecursiveOperationResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RecursiveOperationResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RecursiveOperationResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RecursiveOperationResponse::SharedDtor, + static_cast(&RecursiveOperationResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_._cached_size_), + false, + }, + &RecursiveOperationResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void RecursiveOperationResponse::InternalSwap(RecursiveOperationResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RecursiveOperationResponse_class_data_ = + RecursiveOperationResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RecursiveOperationResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RecursiveOperationResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RecursiveOperationResponse_class_data_.tc_table); + return RecursiveOperationResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 3, 0, 2> +RecursiveOperationResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RecursiveOperationResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RecursiveOperationResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.PeerDescriptor routingPath = 4; + {::_pbi::TcParser::FastMtR1, + {34, 2, 2, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.routingpath_)}}, + // repeated .dht.PeerDescriptor closestConnectedNodes = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.closestconnectednodes_)}}, + // repeated .dht.DataEntry dataEntries = 2; + {::_pbi::TcParser::FastMtR1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.dataentries_)}}, + // bool noCloserNodesFound = 3; + {::_pbi::TcParser::FastV8S1, + {24, 3, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.noclosernodesfound_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor closestConnectedNodes = 1; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.closestconnectednodes_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.DataEntry dataEntries = 2; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.dataentries_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool noCloserNodesFound = 3; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.noclosernodesfound_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // repeated .dht.PeerDescriptor routingPath = 4; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.routingpath_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::DataEntry>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + }}, +}; +void RecursiveOperationResponse::InternalSwap(RecursiveOperationResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RecursiveOperationResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[11]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PingRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PingRequest, _impl_._has_bits_); }; -PingRequest::PingRequest(::google::protobuf::Arena* arena) +PingRequest::PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.PingRequest) } -inline PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::PingRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + requestid_(arena, from.requestid_) {} PingRequest::PingRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PingRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.PingRequest) } -inline PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + requestid_(arena) {} -inline void PingRequest::SharedCtor(::_pb::Arena* arena) { +inline void PingRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PingRequest::~PingRequest() { // @@protoc_insertion_point(destructor:dht.PingRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PingRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void PingRequest::SharedDtor(MessageLite& self) { + PingRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PingRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PingRequest(arena); +} +constexpr auto PingRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PingRequest), + alignof(PingRequest)); +} +constexpr auto PingRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PingRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PingRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PingRequest::SharedDtor, + static_cast(&PingRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PingRequest, _impl_._cached_size_), + false, + }, + &PingRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PingRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PingRequest::InternalSwap(PingRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PingRequest_class_data_ = + PingRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PingRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PingRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PingRequest_class_data_.tc_table); + return PingRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 33, 2> +PingRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PingRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + PingRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::PingRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PingRequest, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(PingRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\17\11\0\0\0\0\0\0" + "dht.PingRequest" + "requestId" + }}, +}; +void PingRequest::InternalSwap(PingRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PingRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[12]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PingResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PingResponse, _impl_._has_bits_); }; -PingResponse::PingResponse(::google::protobuf::Arena* arena) +PingResponse::PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.PingResponse) } -inline PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::PingResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + requestid_(arena, from.requestid_) {} PingResponse::PingResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PingResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.PingResponse) } -inline PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + requestid_(arena) {} -inline void PingResponse::SharedCtor(::_pb::Arena* arena) { +inline void PingResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PingResponse::~PingResponse() { // @@protoc_insertion_point(destructor:dht.PingResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PingResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void PingResponse::SharedDtor(MessageLite& self) { + PingResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PingResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PingResponse(arena); +} +constexpr auto PingResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PingResponse), + alignof(PingResponse)); +} +constexpr auto PingResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PingResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PingResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PingResponse::SharedDtor, + static_cast(&PingResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PingResponse, _impl_._cached_size_), + false, + }, + &PingResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PingResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PingResponse::InternalSwap(PingResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PingResponse_class_data_ = + PingResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PingResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PingResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PingResponse_class_data_.tc_table); + return PingResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 34, 2> +PingResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PingResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + PingResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::PingResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PingResponse, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(PingResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\20\11\0\0\0\0\0\0" + "dht.PingResponse" + "requestId" + }}, +}; +void PingResponse::InternalSwap(PingResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PingResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[13]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -2558,14 +4010,22 @@ class LeaveNotice::_Internal { public: }; -LeaveNotice::LeaveNotice(::google::protobuf::Arena* arena) +LeaveNotice::LeaveNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, LeaveNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.LeaveNotice) } LeaveNotice::LeaveNotice( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LeaveNotice& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, LeaveNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE LeaveNotice* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -2574,62 +4034,103 @@ LeaveNotice::LeaveNotice( // @@protoc_insertion_point(copy_constructor:dht.LeaveNotice) } +inline void* PROTOBUF_NONNULL LeaveNotice::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LeaveNotice(arena); +} +constexpr auto LeaveNotice::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(LeaveNotice), + alignof(LeaveNotice)); +} +constexpr auto LeaveNotice::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LeaveNotice_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LeaveNotice::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LeaveNotice::SharedDtor, + static_cast(&LeaveNotice::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LeaveNotice, _impl_._cached_size_), + false, + }, + &LeaveNotice::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LeaveNotice_class_data_ = + LeaveNotice::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LeaveNotice::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LeaveNotice_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LeaveNotice_class_data_.tc_table); + return LeaveNotice_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +LeaveNotice::_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 + LeaveNotice_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::LeaveNotice>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata LeaveNotice::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[14]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerDescriptor::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._has_bits_); - static const ::dht::ConnectivityMethod& udp(const PeerDescriptor* msg); - static void set_has_udp(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::dht::ConnectivityMethod& tcp(const PeerDescriptor* msg); - static void set_has_tcp(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::dht::ConnectivityMethod& websocket(const PeerDescriptor* msg); - static void set_has_websocket(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_region(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_ipaddress(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_publickey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_signature(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._has_bits_); }; -const ::dht::ConnectivityMethod& PeerDescriptor::_Internal::udp(const PeerDescriptor* msg) { - return *msg->_impl_.udp_; -} -const ::dht::ConnectivityMethod& PeerDescriptor::_Internal::tcp(const PeerDescriptor* msg) { - return *msg->_impl_.tcp_; -} -const ::dht::ConnectivityMethod& PeerDescriptor::_Internal::websocket(const PeerDescriptor* msg) { - return *msg->_impl_.websocket_; -} -PeerDescriptor::PeerDescriptor(::google::protobuf::Arena* arena) +PeerDescriptor::PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PeerDescriptor_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.PeerDescriptor) } -inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::PeerDescriptor& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, nodeid_(arena, from.nodeid_), @@ -2637,27 +4138,31 @@ inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( signature_(arena, from.signature_) {} PeerDescriptor::PeerDescriptor( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PeerDescriptor& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PeerDescriptor_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PeerDescriptor* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.udp_ = (cached_has_bits & 0x00000004u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.udp_) + _impl_.udp_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.udp_) : nullptr; - _impl_.tcp_ = (cached_has_bits & 0x00000008u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.tcp_) + _impl_.tcp_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.tcp_) : nullptr; - _impl_.websocket_ = (cached_has_bits & 0x00000010u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.websocket_) + _impl_.websocket_ = (CheckHasBit(cached_has_bits, 0x00000020U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.websocket_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, type_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, type_), offsetof(Impl_, ipaddress_) - offsetof(Impl_, type_) + @@ -2665,17 +4170,17 @@ PeerDescriptor::PeerDescriptor( // @@protoc_insertion_point(copy_constructor:dht.PeerDescriptor) } -inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, nodeid_(arena), publickey_(arena), signature_(arena) {} -inline void PeerDescriptor::SharedCtor(::_pb::Arena* arena) { +inline void PeerDescriptor::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, udp_), 0, offsetof(Impl_, ipaddress_) - @@ -2684,61 +4189,210 @@ inline void PeerDescriptor::SharedCtor(::_pb::Arena* arena) { } PeerDescriptor::~PeerDescriptor() { // @@protoc_insertion_point(destructor:dht.PeerDescriptor) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PeerDescriptor::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.nodeid_.Destroy(); - _impl_.publickey_.Destroy(); - _impl_.signature_.Destroy(); - delete _impl_.udp_; - delete _impl_.tcp_; - delete _impl_.websocket_; - _impl_.~Impl_(); +inline void PeerDescriptor::SharedDtor(MessageLite& self) { + PeerDescriptor& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.nodeid_.Destroy(); + this_._impl_.publickey_.Destroy(); + this_._impl_.signature_.Destroy(); + delete this_._impl_.udp_; + delete this_._impl_.tcp_; + delete this_._impl_.websocket_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PeerDescriptor::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PeerDescriptor(arena); +} +constexpr auto PeerDescriptor::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PeerDescriptor), + alignof(PeerDescriptor)); +} +constexpr auto PeerDescriptor::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PeerDescriptor_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PeerDescriptor::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PeerDescriptor::SharedDtor, + static_cast(&PeerDescriptor::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._cached_size_), + false, + }, + &PeerDescriptor::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PeerDescriptor::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PeerDescriptor::InternalSwap(PeerDescriptor* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_ = + PeerDescriptor::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PeerDescriptor::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PeerDescriptor_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PeerDescriptor_class_data_.tc_table); + return PeerDescriptor_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 9, 3, 0, 2> +PeerDescriptor::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + PeerDescriptor_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::PeerDescriptor>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bytes nodeId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.nodeid_)}}, + // .dht.NodeType type = 2; + {::_pbi::TcParser::FastV32S1, + {16, 6, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.type_)}}, + // .dht.ConnectivityMethod udp = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.udp_)}}, + // .dht.ConnectivityMethod tcp = 4; + {::_pbi::TcParser::FastMtS1, + {34, 4, 1, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.tcp_)}}, + // .dht.ConnectivityMethod websocket = 5; + {::_pbi::TcParser::FastMtS1, + {42, 5, 2, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.websocket_)}}, + // optional uint32 region = 6; + {::_pbi::TcParser::FastV32S1, + {48, 7, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.region_)}}, + // optional uint32 ipAddress = 7; + {::_pbi::TcParser::FastV32S1, + {56, 8, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.ipaddress_)}}, + // optional bytes publicKey = 8; + {::_pbi::TcParser::FastBS1, + {66, 1, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.publickey_)}}, + // optional bytes signature = 9; + {::_pbi::TcParser::FastBS1, + {74, 2, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.signature_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes nodeId = 1; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.nodeid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .dht.NodeType type = 2; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.type_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .dht.ConnectivityMethod udp = 3; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.udp_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityMethod tcp = 4; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.tcp_), _Internal::kHasBitsOffset + 4, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityMethod websocket = 5; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.websocket_), _Internal::kHasBitsOffset + 5, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional uint32 region = 6; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.region_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 ipAddress = 7; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.ipaddress_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional bytes publicKey = 8; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.publickey_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // optional bytes signature = 9; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.signature_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + }}, + {{ + }}, +}; +void PeerDescriptor::InternalSwap(PeerDescriptor* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PeerDescriptor::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[15]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityMethod::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._has_bits_); }; -ConnectivityMethod::ConnectivityMethod(::google::protobuf::Arena* arena) +ConnectivityMethod::ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityMethod_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ConnectivityMethod) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : host_(arena, from.host_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ConnectivityMethod& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + host_(arena, from.host_) {} ConnectivityMethod::ConnectivityMethod( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityMethod& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityMethod_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityMethod* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); - ::memcpy(reinterpret_cast(&_impl_) + + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, port_), offsetof(Impl_, tls_) - offsetof(Impl_, port_) + @@ -2746,15 +4400,15 @@ ConnectivityMethod::ConnectivityMethod( // @@protoc_insertion_point(copy_constructor:dht.ConnectivityMethod) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : host_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + host_(arena) {} -inline void ConnectivityMethod::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityMethod::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), 0, offsetof(Impl_, tls_) - @@ -2763,58 +4417,142 @@ inline void ConnectivityMethod::SharedCtor(::_pb::Arena* arena) { } ConnectivityMethod::~ConnectivityMethod() { // @@protoc_insertion_point(destructor:dht.ConnectivityMethod) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityMethod::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.host_.Destroy(); - _impl_.~Impl_(); +inline void ConnectivityMethod::SharedDtor(MessageLite& self) { + ConnectivityMethod& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.host_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityMethod::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityMethod(arena); +} +constexpr auto ConnectivityMethod::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityMethod), + alignof(ConnectivityMethod)); +} +constexpr auto ConnectivityMethod::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityMethod_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityMethod::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityMethod::SharedDtor, + static_cast(&ConnectivityMethod::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._cached_size_), + false, + }, + &ConnectivityMethod::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityMethod::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityMethod::InternalSwap(ConnectivityMethod* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_ = + ConnectivityMethod::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityMethod::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityMethod_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityMethod_class_data_.tc_table); + return ConnectivityMethod_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 35, 2> +ConnectivityMethod::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ConnectivityMethod_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 port = 1; + {::_pbi::TcParser::FastV32S1, + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.port_)}}, + // string host = 2; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.host_)}}, + // bool tls = 3; + {::_pbi::TcParser::FastV8S1, + {24, 2, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.tls_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 1; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.port_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string host = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.host_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool tls = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.tls_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\26\0\4\0\0\0\0\0" + "dht.ConnectivityMethod" + "host" + }}, +}; +void ConnectivityMethod::InternalSwap(ConnectivityMethod* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityMethod::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[16]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RouteMessageWrapper::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._has_bits_); - static const ::dht::PeerDescriptor& sourcepeer(const RouteMessageWrapper* msg); - static void set_has_sourcepeer(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::dht::Message& message(const RouteMessageWrapper* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& RouteMessageWrapper::_Internal::sourcepeer(const RouteMessageWrapper* msg) { - return *msg->_impl_.sourcepeer_; -} -const ::dht::Message& RouteMessageWrapper::_Internal::message(const RouteMessageWrapper* msg) { - return *msg->_impl_.message_; -} -RouteMessageWrapper::RouteMessageWrapper(::google::protobuf::Arena* arena) +RouteMessageWrapper::RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageWrapper_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RouteMessageWrapper) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RouteMessageWrapper& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, reachablethrough_{visibility, arena, from.reachablethrough_}, @@ -2824,27 +4562,31 @@ inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( target_(arena, from.target_) {} RouteMessageWrapper::RouteMessageWrapper( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageWrapper& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageWrapper_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RouteMessageWrapper* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeer_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcepeer_) + _impl_.sourcepeer_ = (CheckHasBit(cached_has_bits, 0x00000020U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeer_) : nullptr; - _impl_.message_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::dht::Message>(arena, *from._impl_.message_) + _impl_.message_ = (CheckHasBit(cached_has_bits, 0x00000040U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.message_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.RouteMessageWrapper) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, reachablethrough_{visibility, arena}, routingpath_{visibility, arena}, @@ -2852,9 +4594,9 @@ inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( requestid_(arena), target_(arena) {} -inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* arena) { +inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeer_), 0, offsetof(Impl_, message_) - @@ -2863,136 +4605,377 @@ inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* arena) { } RouteMessageWrapper::~RouteMessageWrapper() { // @@protoc_insertion_point(destructor:dht.RouteMessageWrapper) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RouteMessageWrapper::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.target_.Destroy(); - delete _impl_.sourcepeer_; - delete _impl_.message_; - _impl_.~Impl_(); +inline void RouteMessageWrapper::SharedDtor(MessageLite& self) { + RouteMessageWrapper& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.target_.Destroy(); + delete this_._impl_.sourcepeer_; + delete this_._impl_.message_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RouteMessageWrapper::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RouteMessageWrapper(arena); +} +constexpr auto RouteMessageWrapper::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.reachablethrough_) + + decltype(RouteMessageWrapper::_impl_.reachablethrough_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.routingpath_) + + decltype(RouteMessageWrapper::_impl_.routingpath_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.parallelrootnodeids_) + + decltype(RouteMessageWrapper::_impl_.parallelrootnodeids_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(RouteMessageWrapper), alignof(RouteMessageWrapper), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RouteMessageWrapper::PlacementNew_, + sizeof(RouteMessageWrapper), + alignof(RouteMessageWrapper)); + } } - -::_pbi::CachedSize* RouteMessageWrapper::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto RouteMessageWrapper::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RouteMessageWrapper_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RouteMessageWrapper::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RouteMessageWrapper::SharedDtor, + static_cast(&RouteMessageWrapper::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._cached_size_), + false, + }, + &RouteMessageWrapper::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void RouteMessageWrapper::InternalSwap(RouteMessageWrapper* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_ = + RouteMessageWrapper::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RouteMessageWrapper::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RouteMessageWrapper_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RouteMessageWrapper_class_data_.tc_table); + return RouteMessageWrapper_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 4, 60, 2> +RouteMessageWrapper::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _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 + 4, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RouteMessageWrapper_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RouteMessageWrapper>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 3, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.requestid_)}}, + // .dht.PeerDescriptor sourcePeer = 2; + {::_pbi::TcParser::FastMtS1, + {18, 5, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.sourcepeer_)}}, + // bytes target = 3; + {::_pbi::TcParser::FastBS1, + {26, 4, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.target_)}}, + // .dht.Message message = 4; + {::_pbi::TcParser::FastMtS1, + {34, 6, 1, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.message_)}}, + // repeated .dht.PeerDescriptor reachableThrough = 5; + {::_pbi::TcParser::FastMtR1, + {42, 0, 2, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.reachablethrough_)}}, + // repeated .dht.PeerDescriptor routingPath = 6; + {::_pbi::TcParser::FastMtR1, + {50, 1, 3, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.routingpath_)}}, + // repeated string parallelRootNodeIds = 7; + {::_pbi::TcParser::FastUR1, + {58, 2, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.parallelrootnodeids_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.requestid_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.PeerDescriptor sourcePeer = 2; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.sourcepeer_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes target = 3; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.target_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .dht.Message message = 4; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.message_), _Internal::kHasBitsOffset + 6, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor reachableThrough = 5; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.reachablethrough_), _Internal::kHasBitsOffset + 0, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor routingPath = 6; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.routingpath_), _Internal::kHasBitsOffset + 1, 3, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated string parallelRootNodeIds = 7; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.parallelrootnodeids_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::Message>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\27\11\0\0\0\0\0\23" + "dht.RouteMessageWrapper" + "requestId" + "parallelRootNodeIds" + }}, +}; +void RouteMessageWrapper::InternalSwap(RouteMessageWrapper* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RouteMessageWrapper::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[17]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RouteMessageAck::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._has_bits_); - static void set_has_error(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._has_bits_); }; -RouteMessageAck::RouteMessageAck(::google::protobuf::Arena* arena) +RouteMessageAck::RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageAck_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RouteMessageAck) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RouteMessageAck& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, requestid_(arena, from.requestid_) {} RouteMessageAck::RouteMessageAck( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageAck& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageAck_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RouteMessageAck* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.error_ = from._impl_.error_; // @@protoc_insertion_point(copy_constructor:dht.RouteMessageAck) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, requestid_(arena) {} -inline void RouteMessageAck::SharedCtor(::_pb::Arena* arena) { +inline void RouteMessageAck::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.error_ = {}; } RouteMessageAck::~RouteMessageAck() { // @@protoc_insertion_point(destructor:dht.RouteMessageAck) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RouteMessageAck::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void RouteMessageAck::SharedDtor(MessageLite& self) { + RouteMessageAck& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RouteMessageAck::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RouteMessageAck(arena); +} +constexpr auto RouteMessageAck::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RouteMessageAck), + alignof(RouteMessageAck)); +} +constexpr auto RouteMessageAck::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RouteMessageAck_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RouteMessageAck::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RouteMessageAck::SharedDtor, + static_cast(&RouteMessageAck::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._cached_size_), + false, + }, + &RouteMessageAck::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RouteMessageAck::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RouteMessageAck::InternalSwap(RouteMessageAck* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_ = + RouteMessageAck::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RouteMessageAck::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RouteMessageAck_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RouteMessageAck_class_data_.tc_table); + return RouteMessageAck_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 37, 2> +RouteMessageAck::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._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 + RouteMessageAck_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RouteMessageAck>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // optional .dht.RouteMessageError error = 2; + {::_pbi::TcParser::FastV32S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.error_)}}, + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .dht.RouteMessageError error = 2; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.error_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + "\23\11\0\0\0\0\0\0" + "dht.RouteMessageAck" + "requestId" + }}, +}; +void RouteMessageAck::InternalSwap(RouteMessageAck* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RouteMessageAck::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[18]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._has_bits_); - static void set_has_host(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._has_bits_); }; -ConnectivityRequest::ConnectivityRequest(::google::protobuf::Arena* arena) +ConnectivityRequest::ConnectivityRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ConnectivityRequest) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ConnectivityRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, host_(arena, from.host_) {} ConnectivityRequest::ConnectivityRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); - ::memcpy(reinterpret_cast(&_impl_) + + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, port_), offsetof(Impl_, allowselfsignedcertificate_) - offsetof(Impl_, port_) + @@ -3000,15 +4983,15 @@ ConnectivityRequest::ConnectivityRequest( // @@protoc_insertion_point(copy_constructor:dht.ConnectivityRequest) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, host_(arena) {} -inline void ConnectivityRequest::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), 0, offsetof(Impl_, allowselfsignedcertificate_) - @@ -3017,57 +5000,147 @@ inline void ConnectivityRequest::SharedCtor(::_pb::Arena* arena) { } ConnectivityRequest::~ConnectivityRequest() { // @@protoc_insertion_point(destructor:dht.ConnectivityRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.host_.Destroy(); - _impl_.~Impl_(); +inline void ConnectivityRequest::SharedDtor(MessageLite& self) { + ConnectivityRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.host_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityRequest(arena); +} +constexpr auto ConnectivityRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityRequest), + alignof(ConnectivityRequest)); +} +constexpr auto ConnectivityRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityRequest::SharedDtor, + static_cast(&ConnectivityRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._cached_size_), + false, + }, + &ConnectivityRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityRequest::InternalSwap(ConnectivityRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityRequest_class_data_ = + ConnectivityRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityRequest_class_data_.tc_table); + return ConnectivityRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 36, 2> +ConnectivityRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._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 + ConnectivityRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ConnectivityRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool allowSelfSignedCertificate = 4; + {::_pbi::TcParser::FastV8S1, + {32, 3, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.allowselfsignedcertificate_)}}, + // uint32 port = 1; + {::_pbi::TcParser::FastV32S1, + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.port_)}}, + // bool tls = 2; + {::_pbi::TcParser::FastV8S1, + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.tls_)}}, + // optional string host = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.host_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 1; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.port_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // bool tls = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.tls_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // optional string host = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.host_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool allowSelfSignedCertificate = 4; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.allowselfsignedcertificate_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\27\0\0\4\0\0\0\0" + "dht.ConnectivityRequest" + "host" + }}, +}; +void ConnectivityRequest::InternalSwap(ConnectivityRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[19]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_._has_bits_); - static const ::dht::ConnectivityMethod& websocket(const ConnectivityResponse* msg); - static void set_has_websocket(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_latitude(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_longitude(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_._has_bits_); }; -const ::dht::ConnectivityMethod& ConnectivityResponse::_Internal::websocket(const ConnectivityResponse* msg) { - return *msg->_impl_.websocket_; -} -ConnectivityResponse::ConnectivityResponse(::google::protobuf::Arena* arena) +ConnectivityResponse::ConnectivityResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ConnectivityResponse) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ConnectivityResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, host_(arena, from.host_), @@ -3075,21 +5148,25 @@ inline PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( version_(arena, from.version_) {} ConnectivityResponse::ConnectivityResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.websocket_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.websocket_) + _impl_.websocket_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.websocket_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, latitude_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, latitude_), offsetof(Impl_, ipaddress_) - offsetof(Impl_, latitude_) + @@ -3097,17 +5174,17 @@ ConnectivityResponse::ConnectivityResponse( // @@protoc_insertion_point(copy_constructor:dht.ConnectivityResponse) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, host_(arena), nattype_(arena), version_(arena) {} -inline void ConnectivityResponse::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, websocket_), 0, offsetof(Impl_, ipaddress_) - @@ -3116,93 +5193,209 @@ inline void ConnectivityResponse::SharedCtor(::_pb::Arena* arena) { } ConnectivityResponse::~ConnectivityResponse() { // @@protoc_insertion_point(destructor:dht.ConnectivityResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.host_.Destroy(); - _impl_.nattype_.Destroy(); - _impl_.version_.Destroy(); - delete _impl_.websocket_; - _impl_.~Impl_(); +inline void ConnectivityResponse::SharedDtor(MessageLite& self) { + ConnectivityResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.host_.Destroy(); + this_._impl_.nattype_.Destroy(); + this_._impl_.version_.Destroy(); + delete this_._impl_.websocket_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityResponse(arena); +} +constexpr auto ConnectivityResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityResponse), + alignof(ConnectivityResponse)); +} +constexpr auto ConnectivityResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityResponse::SharedDtor, + static_cast(&ConnectivityResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_._cached_size_), + false, + }, + &ConnectivityResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityResponse::InternalSwap(ConnectivityResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityResponse_class_data_ = + ConnectivityResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityResponse_class_data_.tc_table); + return ConnectivityResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 1, 51, 2> +ConnectivityResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _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), + ConnectivityResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ConnectivityResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string host = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.host_)}}, + // string natType = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.nattype_)}}, + // .dht.ConnectivityMethod websocket = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.websocket_)}}, + // uint32 ipAddress = 4; + {::_pbi::TcParser::FastV32S1, + {32, 6, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.ipaddress_)}}, + // string version = 5; + {::_pbi::TcParser::FastUS1, + {42, 2, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.version_)}}, + // optional double latitude = 6; + {::_pbi::TcParser::FastF64S1, + {49, 4, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.latitude_)}}, + // optional double longitude = 7; + {::_pbi::TcParser::FastF64S1, + {57, 5, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.longitude_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string host = 1; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.host_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string natType = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.nattype_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.ConnectivityMethod websocket = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.websocket_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 ipAddress = 4; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.ipaddress_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string version = 5; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.version_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional double latitude = 6; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.latitude_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // optional double longitude = 7; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.longitude_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + }}, + {{ + "\30\4\7\0\0\7\0\0" + "dht.ConnectivityResponse" + "host" + "natType" + "version" + }}, +}; +void ConnectivityResponse::InternalSwap(ConnectivityResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[20]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HandshakeRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_._has_bits_); - static const ::dht::PeerDescriptor& sourcepeerdescriptor(const HandshakeRequest* msg); - static void set_has_sourcepeerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::dht::PeerDescriptor& targetpeerdescriptor(const HandshakeRequest* msg); - static void set_has_targetpeerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& HandshakeRequest::_Internal::sourcepeerdescriptor(const HandshakeRequest* msg) { - return *msg->_impl_.sourcepeerdescriptor_; -} -const ::dht::PeerDescriptor& HandshakeRequest::_Internal::targetpeerdescriptor(const HandshakeRequest* msg) { - return *msg->_impl_.targetpeerdescriptor_; -} -HandshakeRequest::HandshakeRequest(::google::protobuf::Arena* arena) +HandshakeRequest::HandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.HandshakeRequest) } -inline PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::HandshakeRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, version_(arena, from.version_) {} HandshakeRequest::HandshakeRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HandshakeRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeerdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcepeerdescriptor_) + _impl_.sourcepeerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeerdescriptor_) : nullptr; - _impl_.targetpeerdescriptor_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.targetpeerdescriptor_) + _impl_.targetpeerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.targetpeerdescriptor_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.HandshakeRequest) } -inline PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, version_(arena) {} -inline void HandshakeRequest::SharedCtor(::_pb::Arena* arena) { +inline void HandshakeRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeerdescriptor_), 0, offsetof(Impl_, targetpeerdescriptor_) - @@ -3211,86 +5404,181 @@ inline void HandshakeRequest::SharedCtor(::_pb::Arena* arena) { } HandshakeRequest::~HandshakeRequest() { // @@protoc_insertion_point(destructor:dht.HandshakeRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void HandshakeRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.version_.Destroy(); - delete _impl_.sourcepeerdescriptor_; - delete _impl_.targetpeerdescriptor_; - _impl_.~Impl_(); +inline void HandshakeRequest::SharedDtor(MessageLite& self) { + HandshakeRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.version_.Destroy(); + delete this_._impl_.sourcepeerdescriptor_; + delete this_._impl_.targetpeerdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL HandshakeRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HandshakeRequest(arena); +} +constexpr auto HandshakeRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HandshakeRequest), + alignof(HandshakeRequest)); +} +constexpr auto HandshakeRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HandshakeRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HandshakeRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HandshakeRequest::SharedDtor, + static_cast(&HandshakeRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_._cached_size_), + false, + }, + &HandshakeRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* HandshakeRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void HandshakeRequest::InternalSwap(HandshakeRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HandshakeRequest_class_data_ = + HandshakeRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HandshakeRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HandshakeRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HandshakeRequest_class_data_.tc_table); + return HandshakeRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 36, 2> +HandshakeRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + HandshakeRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::HandshakeRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.sourcepeerdescriptor_)}}, + // optional .dht.PeerDescriptor targetPeerDescriptor = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 1, + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.targetpeerdescriptor_)}}, + // string version = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.version_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.sourcepeerdescriptor_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .dht.PeerDescriptor targetPeerDescriptor = 2; + {PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.targetpeerdescriptor_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string version = 3; + {PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.version_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\24\0\0\7\0\0\0\0" + "dht.HandshakeRequest" + "version" + }}, +}; +void HandshakeRequest::InternalSwap(HandshakeRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HandshakeRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[21]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HandshakeResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_._has_bits_); - static const ::dht::PeerDescriptor& sourcepeerdescriptor(const HandshakeResponse* msg); - static void set_has_sourcepeerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_error(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& HandshakeResponse::_Internal::sourcepeerdescriptor(const HandshakeResponse* msg) { - return *msg->_impl_.sourcepeerdescriptor_; -} -HandshakeResponse::HandshakeResponse(::google::protobuf::Arena* arena) +HandshakeResponse::HandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.HandshakeResponse) } -inline PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::HandshakeResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, version_(arena, from.version_) {} HandshakeResponse::HandshakeResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HandshakeResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeerdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcepeerdescriptor_) + _impl_.sourcepeerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeerdescriptor_) : nullptr; _impl_.error_ = from._impl_.error_; // @@protoc_insertion_point(copy_constructor:dht.HandshakeResponse) } -inline PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, version_(arena) {} -inline void HandshakeResponse::SharedCtor(::_pb::Arena* arena) { +inline void HandshakeResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeerdescriptor_), 0, offsetof(Impl_, error_) - @@ -3299,82 +5587,139 @@ inline void HandshakeResponse::SharedCtor(::_pb::Arena* arena) { } HandshakeResponse::~HandshakeResponse() { // @@protoc_insertion_point(destructor:dht.HandshakeResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void HandshakeResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.version_.Destroy(); - delete _impl_.sourcepeerdescriptor_; - _impl_.~Impl_(); +inline void HandshakeResponse::SharedDtor(MessageLite& self) { + HandshakeResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.version_.Destroy(); + delete this_._impl_.sourcepeerdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL HandshakeResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HandshakeResponse(arena); +} +constexpr auto HandshakeResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HandshakeResponse), + alignof(HandshakeResponse)); +} +constexpr auto HandshakeResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HandshakeResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HandshakeResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HandshakeResponse::SharedDtor, + static_cast(&HandshakeResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_._cached_size_), + false, + }, + &HandshakeResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* HandshakeResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void HandshakeResponse::InternalSwap(HandshakeResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HandshakeResponse_class_data_ = + HandshakeResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HandshakeResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HandshakeResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HandshakeResponse_class_data_.tc_table); + return HandshakeResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 37, 2> +HandshakeResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _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), + HandshakeResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::HandshakeResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.sourcepeerdescriptor_)}}, + // optional .dht.HandshakeError error = 2; + {::_pbi::TcParser::FastV32S1, + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.error_)}}, + // string version = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.version_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.sourcepeerdescriptor_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .dht.HandshakeError error = 2; + {PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.error_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // string version = 3; + {PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.version_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\25\0\0\7\0\0\0\0" + "dht.HandshakeResponse" + "version" + }}, +}; +void HandshakeResponse::InternalSwap(HandshakeResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HandshakeResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[22]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Message::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(Message, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(Message, _impl_._has_bits_); static constexpr ::int32_t kOneofCaseOffset = - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_); - static const ::dht::PeerDescriptor& sourcedescriptor(const Message* msg); - static void set_has_sourcedescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::dht::PeerDescriptor& targetdescriptor(const Message* msg); - static void set_has_targetdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::protorpc::RpcMessage& rpcmessage(const Message* msg); - static const ::dht::ConnectivityRequest& connectivityrequest(const Message* msg); - static const ::dht::ConnectivityResponse& connectivityresponse(const Message* msg); - static const ::dht::HandshakeRequest& handshakerequest(const Message* msg); - static const ::dht::HandshakeResponse& handshakeresponse(const Message* msg); - static const ::dht::RecursiveOperationRequest& recursiveoperationrequest(const Message* msg); + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_); }; -const ::dht::PeerDescriptor& Message::_Internal::sourcedescriptor(const Message* msg) { - return *msg->_impl_.sourcedescriptor_; -} -const ::dht::PeerDescriptor& Message::_Internal::targetdescriptor(const Message* msg) { - return *msg->_impl_.targetdescriptor_; -} -const ::protorpc::RpcMessage& Message::_Internal::rpcmessage(const Message* msg) { - return *msg->_impl_.body_.rpcmessage_; -} -const ::dht::ConnectivityRequest& Message::_Internal::connectivityrequest(const Message* msg) { - return *msg->_impl_.body_.connectivityrequest_; -} -const ::dht::ConnectivityResponse& Message::_Internal::connectivityresponse(const Message* msg) { - return *msg->_impl_.body_.connectivityresponse_; -} -const ::dht::HandshakeRequest& Message::_Internal::handshakerequest(const Message* msg) { - return *msg->_impl_.body_.handshakerequest_; -} -const ::dht::HandshakeResponse& Message::_Internal::handshakeresponse(const Message* msg) { - return *msg->_impl_.body_.handshakeresponse_; -} -const ::dht::RecursiveOperationRequest& Message::_Internal::recursiveoperationrequest(const Message* msg) { - return *msg->_impl_.body_.recursiveoperationrequest_; -} -void Message::set_allocated_rpcmessage(::protorpc::RpcMessage* rpcmessage) { +void Message::set_allocated_rpcmessage(::protorpc::RpcMessage* PROTOBUF_NULLABLE rpcmessage) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (rpcmessage) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(rpcmessage)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(rpcmessage)->GetArena(); if (message_arena != submessage_arena) { rpcmessage = ::google::protobuf::internal::GetOwnedMessage(message_arena, rpcmessage, submessage_arena); } @@ -3384,15 +5729,17 @@ void Message::set_allocated_rpcmessage(::protorpc::RpcMessage* rpcmessage) { // @@protoc_insertion_point(field_set_allocated:dht.Message.rpcMessage) } void Message::clear_rpcmessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kRpcMessage) { if (GetArena() == nullptr) { delete _impl_.body_.rpcmessage_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.rpcmessage_); } clear_has_body(); } } -void Message::set_allocated_connectivityrequest(::dht::ConnectivityRequest* connectivityrequest) { +void Message::set_allocated_connectivityrequest(::dht::ConnectivityRequest* PROTOBUF_NULLABLE connectivityrequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (connectivityrequest) { @@ -3405,7 +5752,7 @@ void Message::set_allocated_connectivityrequest(::dht::ConnectivityRequest* conn } // @@protoc_insertion_point(field_set_allocated:dht.Message.connectivityRequest) } -void Message::set_allocated_connectivityresponse(::dht::ConnectivityResponse* connectivityresponse) { +void Message::set_allocated_connectivityresponse(::dht::ConnectivityResponse* PROTOBUF_NULLABLE connectivityresponse) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (connectivityresponse) { @@ -3418,7 +5765,7 @@ void Message::set_allocated_connectivityresponse(::dht::ConnectivityResponse* co } // @@protoc_insertion_point(field_set_allocated:dht.Message.connectivityResponse) } -void Message::set_allocated_handshakerequest(::dht::HandshakeRequest* handshakerequest) { +void Message::set_allocated_handshakerequest(::dht::HandshakeRequest* PROTOBUF_NULLABLE handshakerequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (handshakerequest) { @@ -3431,7 +5778,7 @@ void Message::set_allocated_handshakerequest(::dht::HandshakeRequest* handshaker } // @@protoc_insertion_point(field_set_allocated:dht.Message.handshakeRequest) } -void Message::set_allocated_handshakeresponse(::dht::HandshakeResponse* handshakeresponse) { +void Message::set_allocated_handshakeresponse(::dht::HandshakeResponse* PROTOBUF_NULLABLE handshakeresponse) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (handshakeresponse) { @@ -3444,7 +5791,7 @@ void Message::set_allocated_handshakeresponse(::dht::HandshakeResponse* handshak } // @@protoc_insertion_point(field_set_allocated:dht.Message.handshakeResponse) } -void Message::set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* recursiveoperationrequest) { +void Message::set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE recursiveoperationrequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (recursiveoperationrequest) { @@ -3457,14 +5804,19 @@ void Message::set_allocated_recursiveoperationrequest(::dht::RecursiveOperationR } // @@protoc_insertion_point(field_set_allocated:dht.Message.recursiveOperationRequest) } -Message::Message(::google::protobuf::Arena* arena) +Message::Message(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Message_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.Message) } -inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::Message& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, messageid_(arena, from.messageid_), @@ -3473,58 +5825,62 @@ inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( _oneof_case_{from._oneof_case_[0]} {} Message::Message( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Message& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Message_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE Message* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcedescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcedescriptor_) + _impl_.sourcedescriptor_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcedescriptor_) : nullptr; - _impl_.targetdescriptor_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.targetdescriptor_) + _impl_.targetdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.targetdescriptor_) : nullptr; switch (body_case()) { case BODY_NOT_SET: break; case kRpcMessage: - _impl_.body_.rpcmessage_ = CreateMaybeMessage<::protorpc::RpcMessage>(arena, *from._impl_.body_.rpcmessage_); + _impl_.body_.rpcmessage_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.rpcmessage_); break; case kConnectivityRequest: - _impl_.body_.connectivityrequest_ = CreateMaybeMessage<::dht::ConnectivityRequest>(arena, *from._impl_.body_.connectivityrequest_); + _impl_.body_.connectivityrequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.connectivityrequest_); break; case kConnectivityResponse: - _impl_.body_.connectivityresponse_ = CreateMaybeMessage<::dht::ConnectivityResponse>(arena, *from._impl_.body_.connectivityresponse_); + _impl_.body_.connectivityresponse_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.connectivityresponse_); break; case kHandshakeRequest: - _impl_.body_.handshakerequest_ = CreateMaybeMessage<::dht::HandshakeRequest>(arena, *from._impl_.body_.handshakerequest_); + _impl_.body_.handshakerequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.handshakerequest_); break; case kHandshakeResponse: - _impl_.body_.handshakeresponse_ = CreateMaybeMessage<::dht::HandshakeResponse>(arena, *from._impl_.body_.handshakeresponse_); + _impl_.body_.handshakeresponse_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.handshakeresponse_); break; case kRecursiveOperationRequest: - _impl_.body_.recursiveoperationrequest_ = CreateMaybeMessage<::dht::RecursiveOperationRequest>(arena, *from._impl_.body_.recursiveoperationrequest_); + _impl_.body_.recursiveoperationrequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.recursiveoperationrequest_); break; } // @@protoc_insertion_point(copy_constructor:dht.Message) } -inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, messageid_(arena), serviceid_(arena), body_{}, _oneof_case_{} {} -inline void Message::SharedCtor(::_pb::Arena* arena) { +inline void Message::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcedescriptor_), 0, offsetof(Impl_, targetdescriptor_) - @@ -3533,58 +5889,74 @@ inline void Message::SharedCtor(::_pb::Arena* arena) { } Message::~Message() { // @@protoc_insertion_point(destructor:dht.Message) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); -} -inline void Message::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.messageid_.Destroy(); - _impl_.serviceid_.Destroy(); - delete _impl_.sourcedescriptor_; - delete _impl_.targetdescriptor_; - if (has_body()) { - clear_body(); + SharedDtor(*this); +} +inline void Message::SharedDtor(MessageLite& self) { + Message& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); } - _impl_.~Impl_(); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.messageid_.Destroy(); + this_._impl_.serviceid_.Destroy(); + delete this_._impl_.sourcedescriptor_; + delete this_._impl_.targetdescriptor_; + if (this_.has_body()) { + this_.clear_body(); + } + this_._impl_.~Impl_(); } void Message::clear_body() { // @@protoc_insertion_point(one_of_clear_start:dht.Message) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); switch (body_case()) { case kRpcMessage: { if (GetArena() == nullptr) { delete _impl_.body_.rpcmessage_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.rpcmessage_); } break; } case kConnectivityRequest: { if (GetArena() == nullptr) { delete _impl_.body_.connectivityrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityrequest_); } break; } case kConnectivityResponse: { if (GetArena() == nullptr) { delete _impl_.body_.connectivityresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityresponse_); } break; } case kHandshakeRequest: { if (GetArena() == nullptr) { delete _impl_.body_.handshakerequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakerequest_); } break; } case kHandshakeResponse: { if (GetArena() == nullptr) { delete _impl_.body_.handshakeresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakeresponse_); } break; } case kRecursiveOperationRequest: { if (GetArena() == nullptr) { delete _impl_.body_.recursiveoperationrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.recursiveoperationrequest_); } break; } @@ -3596,17 +5968,132 @@ void Message::clear_body() { } -::_pbi::CachedSize* Message::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL Message::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) Message(arena); +} +constexpr auto Message::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Message), + alignof(Message)); +} +constexpr auto Message::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_Message_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Message::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Message::SharedDtor, + static_cast(&Message::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Message, _impl_._cached_size_), + false, + }, + &Message::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void Message::InternalSwap(Message* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull Message_class_data_ = + Message::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +Message::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&Message_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(Message_class_data_.tc_table); + return Message_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 10, 8, 46, 2> +Message::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Message, _impl_._has_bits_), + 0, // no _extensions_ + 10, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966272, // skipmap + offsetof(decltype(_table_), field_entries), + 10, // num_field_entries + 8, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + Message_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::Message>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string serviceId = 4; + {::_pbi::TcParser::FastUS1, + {34, 1, 0, + PROTOBUF_FIELD_OFFSET(Message, _impl_.serviceid_)}}, + // string messageId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(Message, _impl_.messageid_)}}, + // .dht.PeerDescriptor sourceDescriptor = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(Message, _impl_.sourcedescriptor_)}}, + // .dht.PeerDescriptor targetDescriptor = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 1, + PROTOBUF_FIELD_OFFSET(Message, _impl_.targetdescriptor_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string messageId = 1; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.messageid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.PeerDescriptor sourceDescriptor = 2; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.sourcedescriptor_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.PeerDescriptor targetDescriptor = 3; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.targetdescriptor_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string serviceId = 4; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.serviceid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .protorpc.RpcMessage rpcMessage = 5; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.rpcmessage_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityRequest connectivityRequest = 6; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.connectivityrequest_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityResponse connectivityResponse = 7; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.connectivityresponse_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.HandshakeRequest handshakeRequest = 8; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.handshakerequest_), _Internal::kOneofCaseOffset + 0, 5, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.HandshakeResponse handshakeResponse = 9; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.handshakeresponse_), _Internal::kOneofCaseOffset + 0, 6, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.RecursiveOperationRequest recursiveOperationRequest = 10; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.recursiveoperationrequest_), _Internal::kOneofCaseOffset + 0, 7, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::protorpc::RpcMessage>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityRequest>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityResponse>()}, + {::_pbi::TcParser::GetTable<::dht::HandshakeRequest>()}, + {::_pbi::TcParser::GetTable<::dht::HandshakeResponse>()}, + {::_pbi::TcParser::GetTable<::dht::RecursiveOperationRequest>()}, + }}, + {{ + "\13\11\0\0\11\0\0\0\0\0\0\0\0\0\0\0" + "dht.Message" + "messageId" + "serviceId" + }}, +}; +void Message::InternalSwap(Message* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata Message::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[23]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -3614,14 +6101,22 @@ class WebsocketConnectionRequest::_Internal { public: }; -WebsocketConnectionRequest::WebsocketConnectionRequest(::google::protobuf::Arena* arena) +WebsocketConnectionRequest::WebsocketConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebsocketConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.WebsocketConnectionRequest) } WebsocketConnectionRequest::WebsocketConnectionRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebsocketConnectionRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebsocketConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE WebsocketConnectionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -3630,11 +6125,79 @@ WebsocketConnectionRequest::WebsocketConnectionRequest( // @@protoc_insertion_point(copy_constructor:dht.WebsocketConnectionRequest) } +inline void* PROTOBUF_NONNULL WebsocketConnectionRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) WebsocketConnectionRequest(arena); +} +constexpr auto WebsocketConnectionRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WebsocketConnectionRequest), + alignof(WebsocketConnectionRequest)); +} +constexpr auto WebsocketConnectionRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_WebsocketConnectionRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &WebsocketConnectionRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &WebsocketConnectionRequest::SharedDtor, + static_cast(&WebsocketConnectionRequest::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(WebsocketConnectionRequest, _impl_._cached_size_), + false, + }, + &WebsocketConnectionRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull WebsocketConnectionRequest_class_data_ = + WebsocketConnectionRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +WebsocketConnectionRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WebsocketConnectionRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WebsocketConnectionRequest_class_data_.tc_table); + return WebsocketConnectionRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +WebsocketConnectionRequest::_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 + WebsocketConnectionRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::WebsocketConnectionRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata WebsocketConnectionRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[24]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -3642,14 +6205,22 @@ class WebrtcConnectionRequest::_Internal { public: }; -WebrtcConnectionRequest::WebrtcConnectionRequest(::google::protobuf::Arena* arena) +WebrtcConnectionRequest::WebrtcConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebrtcConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.WebrtcConnectionRequest) } WebrtcConnectionRequest::WebrtcConnectionRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebrtcConnectionRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebrtcConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE WebrtcConnectionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -3658,543 +6229,1479 @@ WebrtcConnectionRequest::WebrtcConnectionRequest( // @@protoc_insertion_point(copy_constructor:dht.WebrtcConnectionRequest) } +inline void* PROTOBUF_NONNULL WebrtcConnectionRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) WebrtcConnectionRequest(arena); +} +constexpr auto WebrtcConnectionRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WebrtcConnectionRequest), + alignof(WebrtcConnectionRequest)); +} +constexpr auto WebrtcConnectionRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_WebrtcConnectionRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &WebrtcConnectionRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &WebrtcConnectionRequest::SharedDtor, + static_cast(&WebrtcConnectionRequest::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(WebrtcConnectionRequest, _impl_._cached_size_), + false, + }, + &WebrtcConnectionRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull WebrtcConnectionRequest_class_data_ = + WebrtcConnectionRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +WebrtcConnectionRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WebrtcConnectionRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WebrtcConnectionRequest_class_data_.tc_table); + return WebrtcConnectionRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +WebrtcConnectionRequest::_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 + WebrtcConnectionRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::WebrtcConnectionRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata WebrtcConnectionRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[25]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RtcOffer::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_._has_bits_); }; -RtcOffer::RtcOffer(::google::protobuf::Arena* arena) +RtcOffer::RtcOffer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcOffer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RtcOffer) } -inline PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : description_(arena, from.description_), - connectionid_(arena, from.connectionid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RtcOffer& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + description_(arena, from.description_), + connectionid_(arena, from.connectionid_) {} RtcOffer::RtcOffer( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcOffer& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcOffer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RtcOffer* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.RtcOffer) } -inline PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : description_(arena), - connectionid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + description_(arena), + connectionid_(arena) {} -inline void RtcOffer::SharedCtor(::_pb::Arena* arena) { +inline void RtcOffer::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RtcOffer::~RtcOffer() { // @@protoc_insertion_point(destructor:dht.RtcOffer) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RtcOffer::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.description_.Destroy(); - _impl_.connectionid_.Destroy(); - _impl_.~Impl_(); +inline void RtcOffer::SharedDtor(MessageLite& self) { + RtcOffer& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.description_.Destroy(); + this_._impl_.connectionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RtcOffer::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RtcOffer(arena); +} +constexpr auto RtcOffer::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RtcOffer), + alignof(RtcOffer)); +} +constexpr auto RtcOffer::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RtcOffer_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RtcOffer::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RtcOffer::SharedDtor, + static_cast(&RtcOffer::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_._cached_size_), + false, + }, + &RtcOffer::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RtcOffer::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RtcOffer::InternalSwap(RtcOffer* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RtcOffer_class_data_ = + RtcOffer::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RtcOffer::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RtcOffer_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RtcOffer_class_data_.tc_table); + return RtcOffer_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 44, 2> +RtcOffer::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_._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 + RtcOffer_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RtcOffer>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string connectionId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.connectionid_)}}, + // string description = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.description_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string description = 1; + {PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.description_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string connectionId = 2; + {PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.connectionid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\14\13\14\0\0\0\0\0" + "dht.RtcOffer" + "description" + "connectionId" + }}, +}; +void RtcOffer::InternalSwap(RtcOffer* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RtcOffer::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[26]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RtcAnswer::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_._has_bits_); }; -RtcAnswer::RtcAnswer(::google::protobuf::Arena* arena) +RtcAnswer::RtcAnswer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcAnswer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RtcAnswer) } -inline PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : description_(arena, from.description_), - connectionid_(arena, from.connectionid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RtcAnswer& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + description_(arena, from.description_), + connectionid_(arena, from.connectionid_) {} RtcAnswer::RtcAnswer( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcAnswer& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcAnswer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RtcAnswer* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.RtcAnswer) } -inline PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : description_(arena), - connectionid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + description_(arena), + connectionid_(arena) {} -inline void RtcAnswer::SharedCtor(::_pb::Arena* arena) { +inline void RtcAnswer::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RtcAnswer::~RtcAnswer() { // @@protoc_insertion_point(destructor:dht.RtcAnswer) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RtcAnswer::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.description_.Destroy(); - _impl_.connectionid_.Destroy(); - _impl_.~Impl_(); +inline void RtcAnswer::SharedDtor(MessageLite& self) { + RtcAnswer& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.description_.Destroy(); + this_._impl_.connectionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RtcAnswer::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RtcAnswer(arena); +} +constexpr auto RtcAnswer::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RtcAnswer), + alignof(RtcAnswer)); +} +constexpr auto RtcAnswer::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RtcAnswer_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RtcAnswer::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RtcAnswer::SharedDtor, + static_cast(&RtcAnswer::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_._cached_size_), + false, + }, + &RtcAnswer::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RtcAnswer::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RtcAnswer::InternalSwap(RtcAnswer* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RtcAnswer_class_data_ = + RtcAnswer::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RtcAnswer::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RtcAnswer_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RtcAnswer_class_data_.tc_table); + return RtcAnswer_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 45, 2> +RtcAnswer::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_._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 + RtcAnswer_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RtcAnswer>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string connectionId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.connectionid_)}}, + // string description = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.description_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string description = 1; + {PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.description_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string connectionId = 2; + {PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.connectionid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\15\13\14\0\0\0\0\0" + "dht.RtcAnswer" + "description" + "connectionId" + }}, +}; +void RtcAnswer::InternalSwap(RtcAnswer* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RtcAnswer::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[27]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class IceCandidate::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_._has_bits_); }; -IceCandidate::IceCandidate(::google::protobuf::Arena* arena) +IceCandidate::IceCandidate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, IceCandidate_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.IceCandidate) } -inline PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : candidate_(arena, from.candidate_), +PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::IceCandidate& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + candidate_(arena, from.candidate_), mid_(arena, from.mid_), - connectionid_(arena, from.connectionid_), - _cached_size_{0} {} + connectionid_(arena, from.connectionid_) {} IceCandidate::IceCandidate( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IceCandidate& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, IceCandidate_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE IceCandidate* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.IceCandidate) } -inline PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : candidate_(arena), +PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + candidate_(arena), mid_(arena), - connectionid_(arena), - _cached_size_{0} {} + connectionid_(arena) {} -inline void IceCandidate::SharedCtor(::_pb::Arena* arena) { +inline void IceCandidate::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } IceCandidate::~IceCandidate() { // @@protoc_insertion_point(destructor:dht.IceCandidate) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void IceCandidate::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.candidate_.Destroy(); - _impl_.mid_.Destroy(); - _impl_.connectionid_.Destroy(); - _impl_.~Impl_(); +inline void IceCandidate::SharedDtor(MessageLite& self) { + IceCandidate& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.candidate_.Destroy(); + this_._impl_.mid_.Destroy(); + this_._impl_.connectionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL IceCandidate::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) IceCandidate(arena); +} +constexpr auto IceCandidate::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(IceCandidate), + alignof(IceCandidate)); +} +constexpr auto IceCandidate::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_IceCandidate_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IceCandidate::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IceCandidate::SharedDtor, + static_cast(&IceCandidate::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_._cached_size_), + false, + }, + &IceCandidate::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* IceCandidate::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void IceCandidate::InternalSwap(IceCandidate* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull IceCandidate_class_data_ = + IceCandidate::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +IceCandidate::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&IceCandidate_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(IceCandidate_class_data_.tc_table); + return IceCandidate_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 49, 2> +IceCandidate::_table_ = { + { + PROTOBUF_FIELD_OFFSET(IceCandidate, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + IceCandidate_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::IceCandidate>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string candidate = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.candidate_)}}, + // string mid = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.mid_)}}, + // string connectionId = 3; + {::_pbi::TcParser::FastUS1, + {26, 2, 0, + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.connectionid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string candidate = 1; + {PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.candidate_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string mid = 2; + {PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.mid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string connectionId = 3; + {PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.connectionid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\20\11\3\14\0\0\0\0" + "dht.IceCandidate" + "candidate" + "mid" + "connectionId" + }}, +}; +void IceCandidate::InternalSwap(IceCandidate* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata IceCandidate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[28]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class LockRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(LockRequest, _impl_._has_bits_); }; -LockRequest::LockRequest(::google::protobuf::Arena* arena) +LockRequest::LockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.LockRequest) } -inline PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : lockid_(arena, from.lockid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::LockRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + lockid_(arena, from.lockid_) {} LockRequest::LockRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE LockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.LockRequest) } -inline PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : lockid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + lockid_(arena) {} -inline void LockRequest::SharedCtor(::_pb::Arena* arena) { +inline void LockRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } LockRequest::~LockRequest() { // @@protoc_insertion_point(destructor:dht.LockRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void LockRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.lockid_.Destroy(); - _impl_.~Impl_(); +inline void LockRequest::SharedDtor(MessageLite& self) { + LockRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.lockid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL LockRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LockRequest(arena); +} +constexpr auto LockRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(LockRequest), + alignof(LockRequest)); +} +constexpr auto LockRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LockRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LockRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LockRequest::SharedDtor, + static_cast(&LockRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LockRequest, _impl_._cached_size_), + false, + }, + &LockRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* LockRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void LockRequest::InternalSwap(LockRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LockRequest_class_data_ = + LockRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LockRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LockRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LockRequest_class_data_.tc_table); + return LockRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 30, 2> +LockRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(LockRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + LockRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::LockRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string lockId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(LockRequest, _impl_.lockid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string lockId = 1; + {PROTOBUF_FIELD_OFFSET(LockRequest, _impl_.lockid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\17\6\0\0\0\0\0\0" + "dht.LockRequest" + "lockId" + }}, +}; +void LockRequest::InternalSwap(LockRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata LockRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[29]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class UnlockRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_._has_bits_); }; -UnlockRequest::UnlockRequest(::google::protobuf::Arena* arena) +UnlockRequest::UnlockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, UnlockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.UnlockRequest) } -inline PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : lockid_(arena, from.lockid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::UnlockRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + lockid_(arena, from.lockid_) {} UnlockRequest::UnlockRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const UnlockRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, UnlockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE UnlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.UnlockRequest) } -inline PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : lockid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + lockid_(arena) {} -inline void UnlockRequest::SharedCtor(::_pb::Arena* arena) { +inline void UnlockRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } UnlockRequest::~UnlockRequest() { // @@protoc_insertion_point(destructor:dht.UnlockRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void UnlockRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.lockid_.Destroy(); - _impl_.~Impl_(); +inline void UnlockRequest::SharedDtor(MessageLite& self) { + UnlockRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.lockid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL UnlockRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) UnlockRequest(arena); +} +constexpr auto UnlockRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(UnlockRequest), + alignof(UnlockRequest)); +} +constexpr auto UnlockRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_UnlockRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UnlockRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UnlockRequest::SharedDtor, + static_cast(&UnlockRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_._cached_size_), + false, + }, + &UnlockRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* UnlockRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void UnlockRequest::InternalSwap(UnlockRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull UnlockRequest_class_data_ = + UnlockRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +UnlockRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&UnlockRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(UnlockRequest_class_data_.tc_table); + return UnlockRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 32, 2> +UnlockRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(UnlockRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + UnlockRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::UnlockRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string lockId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_.lockid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string lockId = 1; + {PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_.lockid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\21\6\0\0\0\0\0\0" + "dht.UnlockRequest" + "lockId" + }}, +}; +void UnlockRequest::InternalSwap(UnlockRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata UnlockRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[30]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class LockResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(LockResponse, _impl_._has_bits_); }; -LockResponse::LockResponse(::google::protobuf::Arena* arena) +LockResponse::LockResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.LockResponse) } LockResponse::LockResponse( - ::google::protobuf::Arena* arena, const LockResponse& from) - : LockResponse(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE LockResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE LockResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void LockResponse::SharedCtor(::_pb::Arena* arena) { +inline void LockResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.accepted_ = {}; } LockResponse::~LockResponse() { // @@protoc_insertion_point(destructor:dht.LockResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void LockResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void LockResponse::SharedDtor(MessageLite& self) { + LockResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL LockResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LockResponse(arena); +} +constexpr auto LockResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(LockResponse), + alignof(LockResponse)); +} +constexpr auto LockResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LockResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LockResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LockResponse::SharedDtor, + static_cast(&LockResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LockResponse, _impl_._cached_size_), + false, + }, + &LockResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* LockResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void LockResponse::InternalSwap(LockResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LockResponse_class_data_ = + LockResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LockResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LockResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LockResponse_class_data_.tc_table); + return LockResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +LockResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(LockResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + LockResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::LockResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool accepted = 1; + {::_pbi::TcParser::FastV8S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(LockResponse, _impl_.accepted_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool accepted = 1; + {PROTOBUF_FIELD_OFFSET(LockResponse, _impl_.accepted_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; +void LockResponse::InternalSwap(LockResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata LockResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[31]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class DisconnectNotice::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_._has_bits_); }; -DisconnectNotice::DisconnectNotice(::google::protobuf::Arena* arena) +DisconnectNotice::DisconnectNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DisconnectNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.DisconnectNotice) } DisconnectNotice::DisconnectNotice( - ::google::protobuf::Arena* arena, const DisconnectNotice& from) - : DisconnectNotice(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DisconnectNotice& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DisconnectNotice_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE DisconnectNotice::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE DisconnectNotice::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void DisconnectNotice::SharedCtor(::_pb::Arena* arena) { +inline void DisconnectNotice::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.disconnectmode_ = {}; } DisconnectNotice::~DisconnectNotice() { // @@protoc_insertion_point(destructor:dht.DisconnectNotice) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void DisconnectNotice::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void DisconnectNotice::SharedDtor(MessageLite& self) { + DisconnectNotice& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL DisconnectNotice::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) DisconnectNotice(arena); +} +constexpr auto DisconnectNotice::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DisconnectNotice), + alignof(DisconnectNotice)); +} +constexpr auto DisconnectNotice::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_DisconnectNotice_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DisconnectNotice::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DisconnectNotice::SharedDtor, + static_cast(&DisconnectNotice::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_._cached_size_), + false, + }, + &DisconnectNotice::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* DisconnectNotice::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void DisconnectNotice::InternalSwap(DisconnectNotice* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull DisconnectNotice_class_data_ = + DisconnectNotice::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +DisconnectNotice::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&DisconnectNotice_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(DisconnectNotice_class_data_.tc_table); + return DisconnectNotice_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +DisconnectNotice::_table_ = { + { + PROTOBUF_FIELD_OFFSET(DisconnectNotice, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + DisconnectNotice_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::DisconnectNotice>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.DisconnectMode disconnectMode = 1; + {::_pbi::TcParser::FastV32S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_.disconnectmode_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.DisconnectMode disconnectMode = 1; + {PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_.disconnectmode_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + }}, +}; +void DisconnectNotice::InternalSwap(DisconnectNotice* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata DisconnectNotice::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[32]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalFetchDataRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_._has_bits_); }; -ExternalFetchDataRequest::ExternalFetchDataRequest(::google::protobuf::Arena* arena) +ExternalFetchDataRequest::ExternalFetchDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalFetchDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : key_(arena, from.key_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalFetchDataRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + key_(arena, from.key_) {} ExternalFetchDataRequest::ExternalFetchDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalFetchDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ExternalFetchDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : key_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + key_(arena) {} -inline void ExternalFetchDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void ExternalFetchDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExternalFetchDataRequest::~ExternalFetchDataRequest() { // @@protoc_insertion_point(destructor:dht.ExternalFetchDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalFetchDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - _impl_.~Impl_(); +inline void ExternalFetchDataRequest::SharedDtor(MessageLite& self) { + ExternalFetchDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalFetchDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalFetchDataRequest(arena); +} +constexpr auto ExternalFetchDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ExternalFetchDataRequest), + alignof(ExternalFetchDataRequest)); +} +constexpr auto ExternalFetchDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalFetchDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalFetchDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalFetchDataRequest::SharedDtor, + static_cast(&ExternalFetchDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_._cached_size_), + false, + }, + &ExternalFetchDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ExternalFetchDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ExternalFetchDataRequest::InternalSwap(ExternalFetchDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalFetchDataRequest_class_data_ = + ExternalFetchDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalFetchDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalFetchDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalFetchDataRequest_class_data_.tc_table); + return ExternalFetchDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +ExternalFetchDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ExternalFetchDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalFetchDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + }}, +}; +void ExternalFetchDataRequest::InternalSwap(ExternalFetchDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalFetchDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[33]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalFetchDataResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_._has_bits_); }; -ExternalFetchDataResponse::ExternalFetchDataResponse(::google::protobuf::Arena* arena) +ExternalFetchDataResponse::ExternalFetchDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalFetchDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : entries_{visibility, arena, from.entries_}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalFetchDataResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + entries_{visibility, arena, from.entries_} {} ExternalFetchDataResponse::ExternalFetchDataResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalFetchDataResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ExternalFetchDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : entries_{visibility, arena}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + entries_{visibility, arena} {} -inline void ExternalFetchDataResponse::SharedCtor(::_pb::Arena* arena) { +inline void ExternalFetchDataResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExternalFetchDataResponse::~ExternalFetchDataResponse() { // @@protoc_insertion_point(destructor:dht.ExternalFetchDataResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalFetchDataResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void ExternalFetchDataResponse::SharedDtor(MessageLite& self) { + ExternalFetchDataResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalFetchDataResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalFetchDataResponse(arena); +} +constexpr auto ExternalFetchDataResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_.entries_) + + decltype(ExternalFetchDataResponse::_impl_.entries_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(ExternalFetchDataResponse), alignof(ExternalFetchDataResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ExternalFetchDataResponse::PlacementNew_, + sizeof(ExternalFetchDataResponse), + alignof(ExternalFetchDataResponse)); + } } - -::_pbi::CachedSize* ExternalFetchDataResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ExternalFetchDataResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalFetchDataResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalFetchDataResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalFetchDataResponse::SharedDtor, + static_cast(&ExternalFetchDataResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_._cached_size_), + false, + }, + &ExternalFetchDataResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ExternalFetchDataResponse::InternalSwap(ExternalFetchDataResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalFetchDataResponse_class_data_ = + ExternalFetchDataResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalFetchDataResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalFetchDataResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalFetchDataResponse_class_data_.tc_table); + return ExternalFetchDataResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +ExternalFetchDataResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _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), + ExternalFetchDataResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalFetchDataResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.DataEntry entries = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_.entries_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.DataEntry entries = 1; + {PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_.entries_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::DataEntry>()}, + }}, + {{ + }}, +}; +void ExternalFetchDataResponse::InternalSwap(ExternalFetchDataResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalFetchDataResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[34]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace dht @@ -4203,4 +7710,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.h b/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.h index 6d11615b..da1456b5 100644 --- a/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.h +++ b/packages/streamr-dht/src/proto/packages/dht/protos/DhtRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/dht/protos/DhtRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh +#ifndef packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh +#define packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -31,6 +25,7 @@ #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/generated_enum_reflection.h" @@ -49,7 +44,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -58,117 +54,183 @@ class AnyMetadata; struct TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto; +} // extern "C" namespace dht { +enum DisconnectMode : int; +extern const uint32_t DisconnectMode_internal_data_[]; +enum HandshakeError : int; +extern const uint32_t HandshakeError_internal_data_[]; +enum NodeType : int; +extern const uint32_t NodeType_internal_data_[]; +enum RecursiveOperation : int; +extern const uint32_t RecursiveOperation_internal_data_[]; +enum RouteMessageError : int; +extern const uint32_t RouteMessageError_internal_data_[]; +enum RpcResponseError : int; +extern const uint32_t RpcResponseError_internal_data_[]; class ClosestPeersRequest; struct ClosestPeersRequestDefaultTypeInternal; extern ClosestPeersRequestDefaultTypeInternal _ClosestPeersRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_; class ClosestPeersResponse; struct ClosestPeersResponseDefaultTypeInternal; extern ClosestPeersResponseDefaultTypeInternal _ClosestPeersResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_; class ClosestRingPeersRequest; struct ClosestRingPeersRequestDefaultTypeInternal; extern ClosestRingPeersRequestDefaultTypeInternal _ClosestRingPeersRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersRequest_class_data_; class ClosestRingPeersResponse; struct ClosestRingPeersResponseDefaultTypeInternal; extern ClosestRingPeersResponseDefaultTypeInternal _ClosestRingPeersResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersResponse_class_data_; class ConnectivityMethod; struct ConnectivityMethodDefaultTypeInternal; extern ConnectivityMethodDefaultTypeInternal _ConnectivityMethod_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_; class ConnectivityRequest; struct ConnectivityRequestDefaultTypeInternal; extern ConnectivityRequestDefaultTypeInternal _ConnectivityRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityRequest_class_data_; class ConnectivityResponse; struct ConnectivityResponseDefaultTypeInternal; extern ConnectivityResponseDefaultTypeInternal _ConnectivityResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityResponse_class_data_; class DataEntry; struct DataEntryDefaultTypeInternal; extern DataEntryDefaultTypeInternal _DataEntry_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull DataEntry_class_data_; class DisconnectNotice; struct DisconnectNoticeDefaultTypeInternal; extern DisconnectNoticeDefaultTypeInternal _DisconnectNotice_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull DisconnectNotice_class_data_; class ExternalFetchDataRequest; struct ExternalFetchDataRequestDefaultTypeInternal; extern ExternalFetchDataRequestDefaultTypeInternal _ExternalFetchDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataRequest_class_data_; class ExternalFetchDataResponse; struct ExternalFetchDataResponseDefaultTypeInternal; extern ExternalFetchDataResponseDefaultTypeInternal _ExternalFetchDataResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataResponse_class_data_; class ExternalStoreDataRequest; struct ExternalStoreDataRequestDefaultTypeInternal; extern ExternalStoreDataRequestDefaultTypeInternal _ExternalStoreDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataRequest_class_data_; class ExternalStoreDataResponse; struct ExternalStoreDataResponseDefaultTypeInternal; extern ExternalStoreDataResponseDefaultTypeInternal _ExternalStoreDataResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataResponse_class_data_; class HandshakeRequest; struct HandshakeRequestDefaultTypeInternal; extern HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HandshakeRequest_class_data_; class HandshakeResponse; struct HandshakeResponseDefaultTypeInternal; extern HandshakeResponseDefaultTypeInternal _HandshakeResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HandshakeResponse_class_data_; class IceCandidate; struct IceCandidateDefaultTypeInternal; extern IceCandidateDefaultTypeInternal _IceCandidate_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull IceCandidate_class_data_; class LeaveNotice; struct LeaveNoticeDefaultTypeInternal; extern LeaveNoticeDefaultTypeInternal _LeaveNotice_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LeaveNotice_class_data_; class LockRequest; struct LockRequestDefaultTypeInternal; extern LockRequestDefaultTypeInternal _LockRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LockRequest_class_data_; class LockResponse; struct LockResponseDefaultTypeInternal; extern LockResponseDefaultTypeInternal _LockResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LockResponse_class_data_; class Message; struct MessageDefaultTypeInternal; extern MessageDefaultTypeInternal _Message_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull Message_class_data_; class PeerDescriptor; struct PeerDescriptorDefaultTypeInternal; extern PeerDescriptorDefaultTypeInternal _PeerDescriptor_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_; class PingRequest; struct PingRequestDefaultTypeInternal; extern PingRequestDefaultTypeInternal _PingRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PingRequest_class_data_; class PingResponse; struct PingResponseDefaultTypeInternal; extern PingResponseDefaultTypeInternal _PingResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PingResponse_class_data_; class RecursiveOperationRequest; struct RecursiveOperationRequestDefaultTypeInternal; extern RecursiveOperationRequestDefaultTypeInternal _RecursiveOperationRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationRequest_class_data_; class RecursiveOperationResponse; struct RecursiveOperationResponseDefaultTypeInternal; extern RecursiveOperationResponseDefaultTypeInternal _RecursiveOperationResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationResponse_class_data_; class ReplicateDataRequest; struct ReplicateDataRequestDefaultTypeInternal; extern ReplicateDataRequestDefaultTypeInternal _ReplicateDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ReplicateDataRequest_class_data_; class RouteMessageAck; struct RouteMessageAckDefaultTypeInternal; extern RouteMessageAckDefaultTypeInternal _RouteMessageAck_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_; class RouteMessageWrapper; struct RouteMessageWrapperDefaultTypeInternal; extern RouteMessageWrapperDefaultTypeInternal _RouteMessageWrapper_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_; class RtcAnswer; struct RtcAnswerDefaultTypeInternal; extern RtcAnswerDefaultTypeInternal _RtcAnswer_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RtcAnswer_class_data_; class RtcOffer; struct RtcOfferDefaultTypeInternal; extern RtcOfferDefaultTypeInternal _RtcOffer_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RtcOffer_class_data_; class StoreDataRequest; struct StoreDataRequestDefaultTypeInternal; extern StoreDataRequestDefaultTypeInternal _StoreDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StoreDataRequest_class_data_; class StoreDataResponse; struct StoreDataResponseDefaultTypeInternal; extern StoreDataResponseDefaultTypeInternal _StoreDataResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StoreDataResponse_class_data_; class UnlockRequest; struct UnlockRequestDefaultTypeInternal; extern UnlockRequestDefaultTypeInternal _UnlockRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull UnlockRequest_class_data_; class WebrtcConnectionRequest; struct WebrtcConnectionRequestDefaultTypeInternal; extern WebrtcConnectionRequestDefaultTypeInternal _WebrtcConnectionRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WebrtcConnectionRequest_class_data_; class WebsocketConnectionRequest; struct WebsocketConnectionRequestDefaultTypeInternal; extern WebsocketConnectionRequestDefaultTypeInternal _WebsocketConnectionRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WebsocketConnectionRequest_class_data_; } // namespace dht namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::dht::DisconnectMode_internal_data_> + internal::EnumTraitsImpl::value<::dht::DisconnectMode>; +template <> +internal::EnumTraitsT<::dht::HandshakeError_internal_data_> + internal::EnumTraitsImpl::value<::dht::HandshakeError>; +template <> +internal::EnumTraitsT<::dht::NodeType_internal_data_> + internal::EnumTraitsImpl::value<::dht::NodeType>; +template <> +internal::EnumTraitsT<::dht::RecursiveOperation_internal_data_> + internal::EnumTraitsImpl::value<::dht::RecursiveOperation>; +template <> +internal::EnumTraitsT<::dht::RouteMessageError_internal_data_> + internal::EnumTraitsImpl::value<::dht::RouteMessageError>; +template <> +internal::EnumTraitsT<::dht::RpcResponseError_internal_data_> + internal::EnumTraitsImpl::value<::dht::RpcResponseError>; } // namespace protobuf } // namespace google @@ -178,67 +240,73 @@ enum RecursiveOperation : int { FETCH_DATA = 1, DELETE_DATA = 2, RecursiveOperation_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RecursiveOperation_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RecursiveOperation_IsValid(int value); extern const uint32_t RecursiveOperation_internal_data_[]; -constexpr RecursiveOperation RecursiveOperation_MIN = static_cast(0); -constexpr RecursiveOperation RecursiveOperation_MAX = static_cast(2); -constexpr int RecursiveOperation_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -RecursiveOperation_descriptor(); +inline constexpr RecursiveOperation RecursiveOperation_MIN = + static_cast(0); +inline constexpr RecursiveOperation RecursiveOperation_MAX = + static_cast(2); +inline bool RecursiveOperation_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int RecursiveOperation_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RecursiveOperation_descriptor(); template -const std::string& RecursiveOperation_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RecursiveOperation_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RecursiveOperation_Name()."); return RecursiveOperation_Name(static_cast(value)); } template <> -inline const std::string& RecursiveOperation_Name(RecursiveOperation value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RecursiveOperation_Name(RecursiveOperation value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RecursiveOperation_Parse(absl::string_view name, RecursiveOperation* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RecursiveOperation_descriptor(), name, value); +inline bool RecursiveOperation_Parse( + ::absl::string_view name, RecursiveOperation* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RecursiveOperation_descriptor(), name, + value); } enum NodeType : int { NODEJS = 0, BROWSER = 1, NodeType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), NodeType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool NodeType_IsValid(int value); extern const uint32_t NodeType_internal_data_[]; -constexpr NodeType NodeType_MIN = static_cast(0); -constexpr NodeType NodeType_MAX = static_cast(1); -constexpr int NodeType_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -NodeType_descriptor(); +inline constexpr NodeType NodeType_MIN = + static_cast(0); +inline constexpr NodeType NodeType_MAX = + static_cast(1); +inline bool NodeType_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int NodeType_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL NodeType_descriptor(); template -const std::string& NodeType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& NodeType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to NodeType_Name()."); return NodeType_Name(static_cast(value)); } template <> -inline const std::string& NodeType_Name(NodeType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& NodeType_Name(NodeType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool NodeType_Parse(absl::string_view name, NodeType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - NodeType_descriptor(), name, value); +inline bool NodeType_Parse( + ::absl::string_view name, NodeType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(NodeType_descriptor(), name, + value); } enum RpcResponseError : int { SERVER_TIMOUT = 0, @@ -246,135 +314,147 @@ enum RpcResponseError : int { SERVER_ERROR = 2, UNKNOWN_RPC_METHOD = 3, RpcResponseError_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RpcResponseError_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RpcResponseError_IsValid(int value); extern const uint32_t RpcResponseError_internal_data_[]; -constexpr RpcResponseError RpcResponseError_MIN = static_cast(0); -constexpr RpcResponseError RpcResponseError_MAX = static_cast(3); -constexpr int RpcResponseError_ARRAYSIZE = 3 + 1; -const ::google::protobuf::EnumDescriptor* -RpcResponseError_descriptor(); +inline constexpr RpcResponseError RpcResponseError_MIN = + static_cast(0); +inline constexpr RpcResponseError RpcResponseError_MAX = + static_cast(3); +inline bool RpcResponseError_IsValid(int value) { + return 0 <= value && value <= 3; +} +inline constexpr int RpcResponseError_ARRAYSIZE = 3 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcResponseError_descriptor(); template -const std::string& RpcResponseError_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RpcResponseError_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RpcResponseError_Name()."); return RpcResponseError_Name(static_cast(value)); } template <> -inline const std::string& RpcResponseError_Name(RpcResponseError value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RpcResponseError_Name(RpcResponseError value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RpcResponseError_Parse(absl::string_view name, RpcResponseError* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RpcResponseError_descriptor(), name, value); +inline bool RpcResponseError_Parse( + ::absl::string_view name, RpcResponseError* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RpcResponseError_descriptor(), name, + value); } enum RouteMessageError : int { NO_TARGETS = 0, DUPLICATE = 1, STOPPED = 2, RouteMessageError_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RouteMessageError_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RouteMessageError_IsValid(int value); extern const uint32_t RouteMessageError_internal_data_[]; -constexpr RouteMessageError RouteMessageError_MIN = static_cast(0); -constexpr RouteMessageError RouteMessageError_MAX = static_cast(2); -constexpr int RouteMessageError_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -RouteMessageError_descriptor(); +inline constexpr RouteMessageError RouteMessageError_MIN = + static_cast(0); +inline constexpr RouteMessageError RouteMessageError_MAX = + static_cast(2); +inline bool RouteMessageError_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int RouteMessageError_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RouteMessageError_descriptor(); template -const std::string& RouteMessageError_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RouteMessageError_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RouteMessageError_Name()."); return RouteMessageError_Name(static_cast(value)); } template <> -inline const std::string& RouteMessageError_Name(RouteMessageError value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RouteMessageError_Name(RouteMessageError value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RouteMessageError_Parse(absl::string_view name, RouteMessageError* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RouteMessageError_descriptor(), name, value); +inline bool RouteMessageError_Parse( + ::absl::string_view name, RouteMessageError* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RouteMessageError_descriptor(), name, + value); } enum HandshakeError : int { DUPLICATE_CONNECTION = 0, INVALID_TARGET_PEER_DESCRIPTOR = 1, UNSUPPORTED_VERSION = 2, HandshakeError_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), HandshakeError_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool HandshakeError_IsValid(int value); extern const uint32_t HandshakeError_internal_data_[]; -constexpr HandshakeError HandshakeError_MIN = static_cast(0); -constexpr HandshakeError HandshakeError_MAX = static_cast(2); -constexpr int HandshakeError_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -HandshakeError_descriptor(); +inline constexpr HandshakeError HandshakeError_MIN = + static_cast(0); +inline constexpr HandshakeError HandshakeError_MAX = + static_cast(2); +inline bool HandshakeError_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int HandshakeError_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL HandshakeError_descriptor(); template -const std::string& HandshakeError_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& HandshakeError_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to HandshakeError_Name()."); return HandshakeError_Name(static_cast(value)); } template <> -inline const std::string& HandshakeError_Name(HandshakeError value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& HandshakeError_Name(HandshakeError value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool HandshakeError_Parse(absl::string_view name, HandshakeError* value) { - return ::google::protobuf::internal::ParseNamedEnum( - HandshakeError_descriptor(), name, value); +inline bool HandshakeError_Parse( + ::absl::string_view name, HandshakeError* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(HandshakeError_descriptor(), name, + value); } enum DisconnectMode : int { NORMAL = 0, LEAVING = 1, DisconnectMode_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), DisconnectMode_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool DisconnectMode_IsValid(int value); extern const uint32_t DisconnectMode_internal_data_[]; -constexpr DisconnectMode DisconnectMode_MIN = static_cast(0); -constexpr DisconnectMode DisconnectMode_MAX = static_cast(1); -constexpr int DisconnectMode_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -DisconnectMode_descriptor(); +inline constexpr DisconnectMode DisconnectMode_MIN = + static_cast(0); +inline constexpr DisconnectMode DisconnectMode_MAX = + static_cast(1); +inline bool DisconnectMode_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int DisconnectMode_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DisconnectMode_descriptor(); template -const std::string& DisconnectMode_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& DisconnectMode_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to DisconnectMode_Name()."); return DisconnectMode_Name(static_cast(value)); } template <> -inline const std::string& DisconnectMode_Name(DisconnectMode value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& DisconnectMode_Name(DisconnectMode value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool DisconnectMode_Parse(absl::string_view name, DisconnectMode* value) { - return ::google::protobuf::internal::ParseNamedEnum( - DisconnectMode_descriptor(), name, value); +inline bool DisconnectMode_Parse( + ::absl::string_view name, DisconnectMode* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(DisconnectMode_descriptor(), name, + value); } // =================================================================== @@ -382,31 +462,31 @@ inline bool DisconnectMode_Parse(absl::string_view name, DisconnectMode* value) // ------------------------------------------------------------------- -class WebsocketConnectionRequest final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.WebsocketConnectionRequest) */ { +class WebsocketConnectionRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.WebsocketConnectionRequest) */ { public: inline WebsocketConnectionRequest() : WebsocketConnectionRequest(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR WebsocketConnectionRequest(::google::protobuf::internal::ConstantInitialized); - inline WebsocketConnectionRequest(const WebsocketConnectionRequest& from) - : WebsocketConnectionRequest(nullptr, from) {} - WebsocketConnectionRequest(WebsocketConnectionRequest&& from) noexcept - : WebsocketConnectionRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WebsocketConnectionRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WebsocketConnectionRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR WebsocketConnectionRequest(::google::protobuf::internal::ConstantInitialized); + inline WebsocketConnectionRequest(const WebsocketConnectionRequest& from) : WebsocketConnectionRequest(nullptr, from) {} + inline WebsocketConnectionRequest(WebsocketConnectionRequest&& from) noexcept + : WebsocketConnectionRequest(nullptr, ::std::move(from)) {} inline WebsocketConnectionRequest& operator=(const WebsocketConnectionRequest& from) { CopyFrom(from); return *this; } inline WebsocketConnectionRequest& operator=(WebsocketConnectionRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -418,47 +498,35 @@ class WebsocketConnectionRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const WebsocketConnectionRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_WebsocketConnectionRequest_default_instance_); } - static inline const WebsocketConnectionRequest* internal_default_instance() { - return reinterpret_cast( - &_WebsocketConnectionRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 24; - - friend void swap(WebsocketConnectionRequest& a, WebsocketConnectionRequest& b) { - a.Swap(&b); - } - inline void Swap(WebsocketConnectionRequest* other) { + static constexpr int kIndexInFileMessages = 24; + friend void swap(WebsocketConnectionRequest& a, WebsocketConnectionRequest& b) { a.Swap(&b); } + inline void Swap(WebsocketConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(WebsocketConnectionRequest* other) { + void UnsafeArenaSwap(WebsocketConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -466,29 +534,42 @@ class WebsocketConnectionRequest final : // implements Message ---------------------------------------------- - WebsocketConnectionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + WebsocketConnectionRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.WebsocketConnectionRequest"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.WebsocketConnectionRequest"; } + + explicit WebsocketConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WebsocketConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebsocketConnectionRequest& from); + WebsocketConnectionRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WebsocketConnectionRequest&& from) noexcept + : WebsocketConnectionRequest(arena) { + *this = ::std::move(from); } - protected: - explicit WebsocketConnectionRequest(::google::protobuf::Arena* arena); - WebsocketConnectionRequest(::google::protobuf::Arena* arena, const WebsocketConnectionRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.WebsocketConnectionRequest) 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; @@ -496,44 +577,37 @@ class WebsocketConnectionRequest final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull WebsocketConnectionRequest_class_data_; +// ------------------------------------------------------------------- -class WebrtcConnectionRequest final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.WebrtcConnectionRequest) */ { +class WebrtcConnectionRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.WebrtcConnectionRequest) */ { public: inline WebrtcConnectionRequest() : WebrtcConnectionRequest(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR WebrtcConnectionRequest(::google::protobuf::internal::ConstantInitialized); - inline WebrtcConnectionRequest(const WebrtcConnectionRequest& from) - : WebrtcConnectionRequest(nullptr, from) {} - WebrtcConnectionRequest(WebrtcConnectionRequest&& from) noexcept - : WebrtcConnectionRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WebrtcConnectionRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WebrtcConnectionRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR WebrtcConnectionRequest(::google::protobuf::internal::ConstantInitialized); + inline WebrtcConnectionRequest(const WebrtcConnectionRequest& from) : WebrtcConnectionRequest(nullptr, from) {} + inline WebrtcConnectionRequest(WebrtcConnectionRequest&& from) noexcept + : WebrtcConnectionRequest(nullptr, ::std::move(from)) {} inline WebrtcConnectionRequest& operator=(const WebrtcConnectionRequest& from) { CopyFrom(from); return *this; } inline WebrtcConnectionRequest& operator=(WebrtcConnectionRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -545,47 +619,35 @@ class WebrtcConnectionRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const WebrtcConnectionRequest& default_instance() { - return *internal_default_instance(); - } - static inline const WebrtcConnectionRequest* internal_default_instance() { - return reinterpret_cast( - &_WebrtcConnectionRequest_default_instance_); + return *reinterpret_cast( + &_WebrtcConnectionRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 25; - - friend void swap(WebrtcConnectionRequest& a, WebrtcConnectionRequest& b) { - a.Swap(&b); - } - inline void Swap(WebrtcConnectionRequest* other) { + static constexpr int kIndexInFileMessages = 25; + friend void swap(WebrtcConnectionRequest& a, WebrtcConnectionRequest& b) { a.Swap(&b); } + inline void Swap(WebrtcConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(WebrtcConnectionRequest* other) { + void UnsafeArenaSwap(WebrtcConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -593,29 +655,42 @@ class WebrtcConnectionRequest final : // implements Message ---------------------------------------------- - WebrtcConnectionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + WebrtcConnectionRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.WebrtcConnectionRequest"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.WebrtcConnectionRequest"; } + + explicit WebrtcConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WebrtcConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebrtcConnectionRequest& from); + WebrtcConnectionRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WebrtcConnectionRequest&& from) noexcept + : WebrtcConnectionRequest(arena) { + *this = ::std::move(from); } - protected: - explicit WebrtcConnectionRequest(::google::protobuf::Arena* arena); - WebrtcConnectionRequest(::google::protobuf::Arena* arena, const WebrtcConnectionRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.WebrtcConnectionRequest) 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; @@ -623,45 +698,38 @@ class WebrtcConnectionRequest final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull WebrtcConnectionRequest_class_data_; +// ------------------------------------------------------------------- -class UnlockRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.UnlockRequest) */ { +class UnlockRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.UnlockRequest) */ { public: inline UnlockRequest() : UnlockRequest(nullptr) {} - ~UnlockRequest() override; - template - explicit PROTOBUF_CONSTEXPR UnlockRequest(::google::protobuf::internal::ConstantInitialized); + ~UnlockRequest() PROTOBUF_FINAL; - inline UnlockRequest(const UnlockRequest& from) - : UnlockRequest(nullptr, from) {} - UnlockRequest(UnlockRequest&& from) noexcept - : UnlockRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UnlockRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UnlockRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR UnlockRequest(::google::protobuf::internal::ConstantInitialized); + inline UnlockRequest(const UnlockRequest& from) : UnlockRequest(nullptr, from) {} + inline UnlockRequest(UnlockRequest&& from) noexcept + : UnlockRequest(nullptr, ::std::move(from)) {} inline UnlockRequest& operator=(const UnlockRequest& from) { CopyFrom(from); return *this; } inline UnlockRequest& operator=(UnlockRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -673,47 +741,35 @@ class UnlockRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const UnlockRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_UnlockRequest_default_instance_); } - static inline const UnlockRequest* internal_default_instance() { - return reinterpret_cast( - &_UnlockRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 30; - - friend void swap(UnlockRequest& a, UnlockRequest& b) { - a.Swap(&b); - } - inline void Swap(UnlockRequest* other) { + static constexpr int kIndexInFileMessages = 30; + friend void swap(UnlockRequest& a, UnlockRequest& b) { a.Swap(&b); } + inline void Swap(UnlockRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(UnlockRequest* other) { + void UnsafeArenaSwap(UnlockRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -721,55 +777,66 @@ class UnlockRequest final : // implements Message ---------------------------------------------- - UnlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + UnlockRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(UnlockRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.UnlockRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UnlockRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.UnlockRequest"; } + + explicit UnlockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + UnlockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const UnlockRequest& from); + UnlockRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, UnlockRequest&& from) noexcept + : UnlockRequest(arena) { + *this = ::std::move(from); } - protected: - explicit UnlockRequest(::google::protobuf::Arena* arena); - UnlockRequest(::google::protobuf::Arena* arena, const UnlockRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kLockIdFieldNumber = 1, }; // string lockId = 1; void clear_lockid() ; - const std::string& lockid() const; - template + const ::std::string& lockid() const; + template void set_lockid(Arg_&& arg, Args_... args); - std::string* mutable_lockid(); - PROTOBUF_NODISCARD std::string* release_lockid(); - void set_allocated_lockid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_lockid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_lockid(); + void set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_lockid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_lockid( - const std::string& value); - std::string* _internal_mutable_lockid(); + const ::std::string& _internal_lockid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_lockid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_lockid(); public: // @@protoc_insertion_point(class_scope:dht.UnlockRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 32, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -778,46 +845,51 @@ class UnlockRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const UnlockRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr lockid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull UnlockRequest_class_data_; +// ------------------------------------------------------------------- -class StoreDataResponse final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.StoreDataResponse) */ { +class StoreDataResponse final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.StoreDataResponse) */ { public: inline StoreDataResponse() : StoreDataResponse(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR StoreDataResponse(::google::protobuf::internal::ConstantInitialized); - inline StoreDataResponse(const StoreDataResponse& from) - : StoreDataResponse(nullptr, from) {} - StoreDataResponse(StoreDataResponse&& from) noexcept - : StoreDataResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StoreDataResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StoreDataResponse)); } +#endif + template + explicit PROTOBUF_CONSTEXPR StoreDataResponse(::google::protobuf::internal::ConstantInitialized); + + inline StoreDataResponse(const StoreDataResponse& from) : StoreDataResponse(nullptr, from) {} + inline StoreDataResponse(StoreDataResponse&& from) noexcept + : StoreDataResponse(nullptr, ::std::move(from)) {} inline StoreDataResponse& operator=(const StoreDataResponse& from) { CopyFrom(from); return *this; } inline StoreDataResponse& operator=(StoreDataResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -829,47 +901,35 @@ class StoreDataResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StoreDataResponse& default_instance() { - return *internal_default_instance(); - } - static inline const StoreDataResponse* internal_default_instance() { - return reinterpret_cast( - &_StoreDataResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(StoreDataResponse& a, StoreDataResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_StoreDataResponse_default_instance_); } - inline void Swap(StoreDataResponse* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(StoreDataResponse& a, StoreDataResponse& b) { a.Swap(&b); } + inline void Swap(StoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StoreDataResponse* other) { + void UnsafeArenaSwap(StoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -877,29 +937,42 @@ class StoreDataResponse final : // implements Message ---------------------------------------------- - StoreDataResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StoreDataResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.StoreDataResponse"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.StoreDataResponse"; } + + explicit StoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataResponse& from); + StoreDataResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StoreDataResponse&& from) noexcept + : StoreDataResponse(arena) { + *this = ::std::move(from); } - protected: - explicit StoreDataResponse(::google::protobuf::Arena* arena); - StoreDataResponse(::google::protobuf::Arena* arena, const StoreDataResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.StoreDataResponse) 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; @@ -907,45 +980,38 @@ class StoreDataResponse final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StoreDataResponse_class_data_; +// ------------------------------------------------------------------- -class RtcOffer final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RtcOffer) */ { +class RtcOffer final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RtcOffer) */ { public: inline RtcOffer() : RtcOffer(nullptr) {} - ~RtcOffer() override; - template - explicit PROTOBUF_CONSTEXPR RtcOffer(::google::protobuf::internal::ConstantInitialized); + ~RtcOffer() PROTOBUF_FINAL; - inline RtcOffer(const RtcOffer& from) - : RtcOffer(nullptr, from) {} - RtcOffer(RtcOffer&& from) noexcept - : RtcOffer() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RtcOffer* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RtcOffer)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RtcOffer(::google::protobuf::internal::ConstantInitialized); + + inline RtcOffer(const RtcOffer& from) : RtcOffer(nullptr, from) {} + inline RtcOffer(RtcOffer&& from) noexcept + : RtcOffer(nullptr, ::std::move(from)) {} inline RtcOffer& operator=(const RtcOffer& from) { CopyFrom(from); return *this; } inline RtcOffer& operator=(RtcOffer&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -957,47 +1023,35 @@ class RtcOffer final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RtcOffer& default_instance() { - return *internal_default_instance(); - } - static inline const RtcOffer* internal_default_instance() { - return reinterpret_cast( - &_RtcOffer_default_instance_); - } - static constexpr int kIndexInFileMessages = - 26; - - friend void swap(RtcOffer& a, RtcOffer& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RtcOffer_default_instance_); } - inline void Swap(RtcOffer* other) { + static constexpr int kIndexInFileMessages = 26; + friend void swap(RtcOffer& a, RtcOffer& b) { a.Swap(&b); } + inline void Swap(RtcOffer* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RtcOffer* other) { + void UnsafeArenaSwap(RtcOffer* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1005,72 +1059,82 @@ class RtcOffer final : // implements Message ---------------------------------------------- - RtcOffer* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RtcOffer* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RtcOffer* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RtcOffer"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RtcOffer* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RtcOffer"; } + + explicit RtcOffer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RtcOffer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcOffer& from); + RtcOffer( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RtcOffer&& from) noexcept + : RtcOffer(arena) { + *this = ::std::move(from); } - protected: - explicit RtcOffer(::google::protobuf::Arena* arena); - RtcOffer(::google::protobuf::Arena* arena, const RtcOffer& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kDescriptionFieldNumber = 1, kConnectionIdFieldNumber = 2, }; // string description = 1; void clear_description() ; - const std::string& description() const; - template + const ::std::string& description() const; + template void set_description(Arg_&& arg, Args_... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_description(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_description(); + void set_allocated_description(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description( - const std::string& value); - std::string* _internal_mutable_description(); + const ::std::string& _internal_description() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_description(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_description(); public: // string connectionId = 2; void clear_connectionid() ; - const std::string& connectionid() const; - template + const ::std::string& connectionid() const; + template void set_connectionid(Arg_&& arg, Args_... args); - std::string* mutable_connectionid(); - PROTOBUF_NODISCARD std::string* release_connectionid(); - void set_allocated_connectionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_connectionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_connectionid(); + void set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_connectionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid( - const std::string& value); - std::string* _internal_mutable_connectionid(); + const ::std::string& _internal_connectionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_connectionid(); public: // @@protoc_insertion_point(class_scope:dht.RtcOffer) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 44, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1079,48 +1143,53 @@ class RtcOffer final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RtcOffer& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr description_; ::google::protobuf::internal::ArenaStringPtr connectionid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RtcOffer_class_data_; +// ------------------------------------------------------------------- -class RtcAnswer final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RtcAnswer) */ { +class RtcAnswer final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RtcAnswer) */ { public: inline RtcAnswer() : RtcAnswer(nullptr) {} - ~RtcAnswer() override; - template - explicit PROTOBUF_CONSTEXPR RtcAnswer(::google::protobuf::internal::ConstantInitialized); + ~RtcAnswer() PROTOBUF_FINAL; - inline RtcAnswer(const RtcAnswer& from) - : RtcAnswer(nullptr, from) {} - RtcAnswer(RtcAnswer&& from) noexcept - : RtcAnswer() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RtcAnswer* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RtcAnswer)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR RtcAnswer(::google::protobuf::internal::ConstantInitialized); + inline RtcAnswer(const RtcAnswer& from) : RtcAnswer(nullptr, from) {} + inline RtcAnswer(RtcAnswer&& from) noexcept + : RtcAnswer(nullptr, ::std::move(from)) {} inline RtcAnswer& operator=(const RtcAnswer& from) { CopyFrom(from); return *this; } inline RtcAnswer& operator=(RtcAnswer&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1132,47 +1201,35 @@ class RtcAnswer final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RtcAnswer& default_instance() { - return *internal_default_instance(); - } - static inline const RtcAnswer* internal_default_instance() { - return reinterpret_cast( - &_RtcAnswer_default_instance_); + return *reinterpret_cast( + &_RtcAnswer_default_instance_); } - static constexpr int kIndexInFileMessages = - 27; - - friend void swap(RtcAnswer& a, RtcAnswer& b) { - a.Swap(&b); - } - inline void Swap(RtcAnswer* other) { + static constexpr int kIndexInFileMessages = 27; + friend void swap(RtcAnswer& a, RtcAnswer& b) { a.Swap(&b); } + inline void Swap(RtcAnswer* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RtcAnswer* other) { + void UnsafeArenaSwap(RtcAnswer* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1180,72 +1237,82 @@ class RtcAnswer final : // implements Message ---------------------------------------------- - RtcAnswer* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RtcAnswer* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RtcAnswer* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RtcAnswer"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RtcAnswer* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RtcAnswer"; } + + explicit RtcAnswer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RtcAnswer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcAnswer& from); + RtcAnswer( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RtcAnswer&& from) noexcept + : RtcAnswer(arena) { + *this = ::std::move(from); } - protected: - explicit RtcAnswer(::google::protobuf::Arena* arena); - RtcAnswer(::google::protobuf::Arena* arena, const RtcAnswer& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kDescriptionFieldNumber = 1, kConnectionIdFieldNumber = 2, }; // string description = 1; void clear_description() ; - const std::string& description() const; - template + const ::std::string& description() const; + template void set_description(Arg_&& arg, Args_... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_description(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_description(); + void set_allocated_description(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description( - const std::string& value); - std::string* _internal_mutable_description(); + const ::std::string& _internal_description() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_description(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_description(); public: // string connectionId = 2; void clear_connectionid() ; - const std::string& connectionid() const; - template + const ::std::string& connectionid() const; + template void set_connectionid(Arg_&& arg, Args_... args); - std::string* mutable_connectionid(); - PROTOBUF_NODISCARD std::string* release_connectionid(); - void set_allocated_connectionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_connectionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_connectionid(); + void set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_connectionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid( - const std::string& value); - std::string* _internal_mutable_connectionid(); + const ::std::string& _internal_connectionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_connectionid(); public: // @@protoc_insertion_point(class_scope:dht.RtcAnswer) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 45, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1254,48 +1321,53 @@ class RtcAnswer final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RtcAnswer& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr description_; ::google::protobuf::internal::ArenaStringPtr connectionid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RtcAnswer_class_data_; +// ------------------------------------------------------------------- -class RouteMessageAck final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RouteMessageAck) */ { +class RouteMessageAck final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RouteMessageAck) */ { public: inline RouteMessageAck() : RouteMessageAck(nullptr) {} - ~RouteMessageAck() override; - template - explicit PROTOBUF_CONSTEXPR RouteMessageAck(::google::protobuf::internal::ConstantInitialized); + ~RouteMessageAck() PROTOBUF_FINAL; - inline RouteMessageAck(const RouteMessageAck& from) - : RouteMessageAck(nullptr, from) {} - RouteMessageAck(RouteMessageAck&& from) noexcept - : RouteMessageAck() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RouteMessageAck* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RouteMessageAck)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR RouteMessageAck(::google::protobuf::internal::ConstantInitialized); + inline RouteMessageAck(const RouteMessageAck& from) : RouteMessageAck(nullptr, from) {} + inline RouteMessageAck(RouteMessageAck&& from) noexcept + : RouteMessageAck(nullptr, ::std::move(from)) {} inline RouteMessageAck& operator=(const RouteMessageAck& from) { CopyFrom(from); return *this; } inline RouteMessageAck& operator=(RouteMessageAck&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1307,47 +1379,35 @@ class RouteMessageAck final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RouteMessageAck& default_instance() { - return *internal_default_instance(); - } - static inline const RouteMessageAck* internal_default_instance() { - return reinterpret_cast( - &_RouteMessageAck_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(RouteMessageAck& a, RouteMessageAck& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RouteMessageAck_default_instance_); } - inline void Swap(RouteMessageAck* other) { + static constexpr int kIndexInFileMessages = 18; + friend void swap(RouteMessageAck& a, RouteMessageAck& b) { a.Swap(&b); } + inline void Swap(RouteMessageAck* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RouteMessageAck* other) { + void UnsafeArenaSwap(RouteMessageAck* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1355,51 +1415,57 @@ class RouteMessageAck final : // implements Message ---------------------------------------------- - RouteMessageAck* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RouteMessageAck* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RouteMessageAck* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RouteMessageAck"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RouteMessageAck* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RouteMessageAck"; } + + explicit RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageAck& from); + RouteMessageAck( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RouteMessageAck&& from) noexcept + : RouteMessageAck(arena) { + *this = ::std::move(from); } - protected: - explicit RouteMessageAck(::google::protobuf::Arena* arena); - RouteMessageAck(::google::protobuf::Arena* arena, const RouteMessageAck& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, kErrorFieldNumber = 2, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional .dht.RouteMessageError error = 2; @@ -1416,6 +1482,11 @@ class RouteMessageAck final : // @@protoc_insertion_point(class_scope:dht.RouteMessageAck) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 37, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1424,49 +1495,53 @@ class RouteMessageAck final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RouteMessageAck& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; int error_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_; +// ------------------------------------------------------------------- -class RecursiveOperationRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RecursiveOperationRequest) */ { +class RecursiveOperationRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RecursiveOperationRequest) */ { public: inline RecursiveOperationRequest() : RecursiveOperationRequest(nullptr) {} - ~RecursiveOperationRequest() override; - template - explicit PROTOBUF_CONSTEXPR RecursiveOperationRequest(::google::protobuf::internal::ConstantInitialized); + ~RecursiveOperationRequest() PROTOBUF_FINAL; - inline RecursiveOperationRequest(const RecursiveOperationRequest& from) - : RecursiveOperationRequest(nullptr, from) {} - RecursiveOperationRequest(RecursiveOperationRequest&& from) noexcept - : RecursiveOperationRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RecursiveOperationRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RecursiveOperationRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RecursiveOperationRequest(::google::protobuf::internal::ConstantInitialized); + + inline RecursiveOperationRequest(const RecursiveOperationRequest& from) : RecursiveOperationRequest(nullptr, from) {} + inline RecursiveOperationRequest(RecursiveOperationRequest&& from) noexcept + : RecursiveOperationRequest(nullptr, ::std::move(from)) {} inline RecursiveOperationRequest& operator=(const RecursiveOperationRequest& from) { CopyFrom(from); return *this; } inline RecursiveOperationRequest& operator=(RecursiveOperationRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1478,47 +1553,35 @@ class RecursiveOperationRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RecursiveOperationRequest& default_instance() { - return *internal_default_instance(); - } - static inline const RecursiveOperationRequest* internal_default_instance() { - return reinterpret_cast( - &_RecursiveOperationRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(RecursiveOperationRequest& a, RecursiveOperationRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RecursiveOperationRequest_default_instance_); } - inline void Swap(RecursiveOperationRequest* other) { + static constexpr int kIndexInFileMessages = 10; + friend void swap(RecursiveOperationRequest& a, RecursiveOperationRequest& b) { a.Swap(&b); } + inline void Swap(RecursiveOperationRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RecursiveOperationRequest* other) { + void UnsafeArenaSwap(RecursiveOperationRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1526,51 +1589,57 @@ class RecursiveOperationRequest final : // implements Message ---------------------------------------------- - RecursiveOperationRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RecursiveOperationRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RecursiveOperationRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RecursiveOperationRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RecursiveOperationRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RecursiveOperationRequest"; } + + explicit RecursiveOperationRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RecursiveOperationRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationRequest& from); + RecursiveOperationRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RecursiveOperationRequest&& from) noexcept + : RecursiveOperationRequest(arena) { + *this = ::std::move(from); } - protected: - explicit RecursiveOperationRequest(::google::protobuf::Arena* arena); - RecursiveOperationRequest(::google::protobuf::Arena* arena, const RecursiveOperationRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kSessionIdFieldNumber = 1, kOperationFieldNumber = 2, }; // string sessionId = 1; void clear_sessionid() ; - const std::string& sessionid() const; - template + const ::std::string& sessionid() const; + template void set_sessionid(Arg_&& arg, Args_... args); - std::string* mutable_sessionid(); - PROTOBUF_NODISCARD std::string* release_sessionid(); - void set_allocated_sessionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_sessionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_sessionid(); + void set_allocated_sessionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_sessionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_sessionid( - const std::string& value); - std::string* _internal_mutable_sessionid(); + const ::std::string& _internal_sessionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_sessionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_sessionid(); public: // .dht.RecursiveOperation operation = 2; @@ -1586,6 +1655,11 @@ class RecursiveOperationRequest final : // @@protoc_insertion_point(class_scope:dht.RecursiveOperationRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 47, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1594,48 +1668,53 @@ class RecursiveOperationRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RecursiveOperationRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr sessionid_; int operation_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationRequest_class_data_; +// ------------------------------------------------------------------- -class PingResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.PingResponse) */ { +class PingResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.PingResponse) */ { public: inline PingResponse() : PingResponse(nullptr) {} - ~PingResponse() override; - template - explicit PROTOBUF_CONSTEXPR PingResponse(::google::protobuf::internal::ConstantInitialized); + ~PingResponse() PROTOBUF_FINAL; - inline PingResponse(const PingResponse& from) - : PingResponse(nullptr, from) {} - PingResponse(PingResponse&& from) noexcept - : PingResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PingResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PingResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR PingResponse(::google::protobuf::internal::ConstantInitialized); + inline PingResponse(const PingResponse& from) : PingResponse(nullptr, from) {} + inline PingResponse(PingResponse&& from) noexcept + : PingResponse(nullptr, ::std::move(from)) {} inline PingResponse& operator=(const PingResponse& from) { CopyFrom(from); return *this; } inline PingResponse& operator=(PingResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1647,47 +1726,35 @@ class PingResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PingResponse& default_instance() { - return *internal_default_instance(); - } - static inline const PingResponse* internal_default_instance() { - return reinterpret_cast( - &_PingResponse_default_instance_); + return *reinterpret_cast( + &_PingResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(PingResponse& a, PingResponse& b) { - a.Swap(&b); - } - inline void Swap(PingResponse* other) { + static constexpr int kIndexInFileMessages = 13; + friend void swap(PingResponse& a, PingResponse& b) { a.Swap(&b); } + inline void Swap(PingResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PingResponse* other) { + void UnsafeArenaSwap(PingResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1695,55 +1762,66 @@ class PingResponse final : // implements Message ---------------------------------------------- - PingResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PingResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PingResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.PingResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PingResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.PingResponse"; } + + explicit PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingResponse& from); + PingResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PingResponse&& from) noexcept + : PingResponse(arena) { + *this = ::std::move(from); } - protected: - explicit PingResponse(::google::protobuf::Arena* arena); - PingResponse(::google::protobuf::Arena* arena, const PingResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.PingResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 34, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1752,47 +1830,52 @@ class PingResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PingResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull PingResponse_class_data_; +// ------------------------------------------------------------------- -class PingRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.PingRequest) */ { +class PingRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.PingRequest) */ { public: inline PingRequest() : PingRequest(nullptr) {} - ~PingRequest() override; - template - explicit PROTOBUF_CONSTEXPR PingRequest(::google::protobuf::internal::ConstantInitialized); + ~PingRequest() PROTOBUF_FINAL; - inline PingRequest(const PingRequest& from) - : PingRequest(nullptr, from) {} - PingRequest(PingRequest&& from) noexcept - : PingRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PingRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PingRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR PingRequest(::google::protobuf::internal::ConstantInitialized); + + inline PingRequest(const PingRequest& from) : PingRequest(nullptr, from) {} + inline PingRequest(PingRequest&& from) noexcept + : PingRequest(nullptr, ::std::move(from)) {} inline PingRequest& operator=(const PingRequest& from) { CopyFrom(from); return *this; } inline PingRequest& operator=(PingRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1804,47 +1887,35 @@ class PingRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PingRequest& default_instance() { - return *internal_default_instance(); - } - static inline const PingRequest* internal_default_instance() { - return reinterpret_cast( - &_PingRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(PingRequest& a, PingRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_PingRequest_default_instance_); } - inline void Swap(PingRequest* other) { + static constexpr int kIndexInFileMessages = 12; + friend void swap(PingRequest& a, PingRequest& b) { a.Swap(&b); } + inline void Swap(PingRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PingRequest* other) { + void UnsafeArenaSwap(PingRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1852,55 +1923,66 @@ class PingRequest final : // implements Message ---------------------------------------------- - PingRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PingRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PingRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.PingRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PingRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.PingRequest"; } + + explicit PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingRequest& from); + PingRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PingRequest&& from) noexcept + : PingRequest(arena) { + *this = ::std::move(from); } - protected: - explicit PingRequest(::google::protobuf::Arena* arena); - PingRequest(::google::protobuf::Arena* arena, const PingRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.PingRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 33, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1909,47 +1991,52 @@ class PingRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PingRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class LockResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.LockResponse) */ { +extern const ::google::protobuf::internal::ClassDataFull PingRequest_class_data_; +// ------------------------------------------------------------------- + +class LockResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.LockResponse) */ { public: inline LockResponse() : LockResponse(nullptr) {} - ~LockResponse() override; - template - explicit PROTOBUF_CONSTEXPR LockResponse(::google::protobuf::internal::ConstantInitialized); + ~LockResponse() PROTOBUF_FINAL; - inline LockResponse(const LockResponse& from) - : LockResponse(nullptr, from) {} - LockResponse(LockResponse&& from) noexcept - : LockResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LockResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LockResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR LockResponse(::google::protobuf::internal::ConstantInitialized); + inline LockResponse(const LockResponse& from) : LockResponse(nullptr, from) {} + inline LockResponse(LockResponse&& from) noexcept + : LockResponse(nullptr, ::std::move(from)) {} inline LockResponse& operator=(const LockResponse& from) { CopyFrom(from); return *this; } inline LockResponse& operator=(LockResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1961,47 +2048,35 @@ class LockResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LockResponse& default_instance() { - return *internal_default_instance(); - } - static inline const LockResponse* internal_default_instance() { - return reinterpret_cast( - &_LockResponse_default_instance_); + return *reinterpret_cast( + &_LockResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 31; - - friend void swap(LockResponse& a, LockResponse& b) { - a.Swap(&b); - } - inline void Swap(LockResponse* other) { + static constexpr int kIndexInFileMessages = 31; + friend void swap(LockResponse& a, LockResponse& b) { a.Swap(&b); } + inline void Swap(LockResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LockResponse* other) { + void UnsafeArenaSwap(LockResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2009,33 +2084,40 @@ class LockResponse final : // implements Message ---------------------------------------------- - LockResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LockResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(LockResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.LockResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(LockResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.LockResponse"; } + + explicit LockResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LockResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockResponse& from); + LockResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LockResponse&& from) noexcept + : LockResponse(arena) { + *this = ::std::move(from); } - protected: - explicit LockResponse(::google::protobuf::Arena* arena); - LockResponse(::google::protobuf::Arena* arena, const LockResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kAcceptedFieldNumber = 1, }; @@ -2052,6 +2134,11 @@ class LockResponse final : // @@protoc_insertion_point(class_scope:dht.LockResponse) 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; @@ -2060,47 +2147,52 @@ class LockResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const LockResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; bool accepted_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull LockResponse_class_data_; +// ------------------------------------------------------------------- -class LockRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.LockRequest) */ { +class LockRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.LockRequest) */ { public: inline LockRequest() : LockRequest(nullptr) {} - ~LockRequest() override; - template - explicit PROTOBUF_CONSTEXPR LockRequest(::google::protobuf::internal::ConstantInitialized); + ~LockRequest() PROTOBUF_FINAL; - inline LockRequest(const LockRequest& from) - : LockRequest(nullptr, from) {} - LockRequest(LockRequest&& from) noexcept - : LockRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LockRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LockRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR LockRequest(::google::protobuf::internal::ConstantInitialized); + + inline LockRequest(const LockRequest& from) : LockRequest(nullptr, from) {} + inline LockRequest(LockRequest&& from) noexcept + : LockRequest(nullptr, ::std::move(from)) {} inline LockRequest& operator=(const LockRequest& from) { CopyFrom(from); return *this; } inline LockRequest& operator=(LockRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2112,47 +2204,35 @@ class LockRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LockRequest& default_instance() { - return *internal_default_instance(); - } - static inline const LockRequest* internal_default_instance() { - return reinterpret_cast( - &_LockRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 29; - - friend void swap(LockRequest& a, LockRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_LockRequest_default_instance_); } - inline void Swap(LockRequest* other) { + static constexpr int kIndexInFileMessages = 29; + friend void swap(LockRequest& a, LockRequest& b) { a.Swap(&b); } + inline void Swap(LockRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LockRequest* other) { + void UnsafeArenaSwap(LockRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2160,55 +2240,66 @@ class LockRequest final : // implements Message ---------------------------------------------- - LockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LockRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(LockRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.LockRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(LockRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.LockRequest"; } + + explicit LockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockRequest& from); + LockRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LockRequest&& from) noexcept + : LockRequest(arena) { + *this = ::std::move(from); } - protected: - explicit LockRequest(::google::protobuf::Arena* arena); - LockRequest(::google::protobuf::Arena* arena, const LockRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kLockIdFieldNumber = 1, }; // string lockId = 1; void clear_lockid() ; - const std::string& lockid() const; - template + const ::std::string& lockid() const; + template void set_lockid(Arg_&& arg, Args_... args); - std::string* mutable_lockid(); - PROTOBUF_NODISCARD std::string* release_lockid(); - void set_allocated_lockid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_lockid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_lockid(); + void set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_lockid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_lockid( - const std::string& value); - std::string* _internal_mutable_lockid(); + const ::std::string& _internal_lockid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_lockid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_lockid(); public: // @@protoc_insertion_point(class_scope:dht.LockRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 30, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2217,46 +2308,51 @@ class LockRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const LockRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr lockid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class LeaveNotice final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.LeaveNotice) */ { +extern const ::google::protobuf::internal::ClassDataFull LockRequest_class_data_; +// ------------------------------------------------------------------- + +class LeaveNotice final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.LeaveNotice) */ { public: inline LeaveNotice() : LeaveNotice(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR LeaveNotice(::google::protobuf::internal::ConstantInitialized); - inline LeaveNotice(const LeaveNotice& from) - : LeaveNotice(nullptr, from) {} - LeaveNotice(LeaveNotice&& from) noexcept - : LeaveNotice() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LeaveNotice* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LeaveNotice)); } +#endif + template + explicit PROTOBUF_CONSTEXPR LeaveNotice(::google::protobuf::internal::ConstantInitialized); + + inline LeaveNotice(const LeaveNotice& from) : LeaveNotice(nullptr, from) {} + inline LeaveNotice(LeaveNotice&& from) noexcept + : LeaveNotice(nullptr, ::std::move(from)) {} inline LeaveNotice& operator=(const LeaveNotice& from) { CopyFrom(from); return *this; } inline LeaveNotice& operator=(LeaveNotice&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2268,47 +2364,35 @@ class LeaveNotice final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LeaveNotice& default_instance() { - return *internal_default_instance(); - } - static inline const LeaveNotice* internal_default_instance() { - return reinterpret_cast( - &_LeaveNotice_default_instance_); + return *reinterpret_cast( + &_LeaveNotice_default_instance_); } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(LeaveNotice& a, LeaveNotice& b) { - a.Swap(&b); - } - inline void Swap(LeaveNotice* other) { + static constexpr int kIndexInFileMessages = 14; + friend void swap(LeaveNotice& a, LeaveNotice& b) { a.Swap(&b); } + inline void Swap(LeaveNotice* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LeaveNotice* other) { + void UnsafeArenaSwap(LeaveNotice* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2316,29 +2400,42 @@ class LeaveNotice final : // implements Message ---------------------------------------------- - LeaveNotice* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LeaveNotice* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.LeaveNotice"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.LeaveNotice"; } + + explicit LeaveNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LeaveNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LeaveNotice& from); + LeaveNotice( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LeaveNotice&& from) noexcept + : LeaveNotice(arena) { + *this = ::std::move(from); } - protected: - explicit LeaveNotice(::google::protobuf::Arena* arena); - LeaveNotice(::google::protobuf::Arena* arena, const LeaveNotice& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.LeaveNotice) 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; @@ -2346,45 +2443,38 @@ class LeaveNotice final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class IceCandidate final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.IceCandidate) */ { +extern const ::google::protobuf::internal::ClassDataFull LeaveNotice_class_data_; +// ------------------------------------------------------------------- + +class IceCandidate final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.IceCandidate) */ { public: inline IceCandidate() : IceCandidate(nullptr) {} - ~IceCandidate() override; - template - explicit PROTOBUF_CONSTEXPR IceCandidate(::google::protobuf::internal::ConstantInitialized); + ~IceCandidate() PROTOBUF_FINAL; - inline IceCandidate(const IceCandidate& from) - : IceCandidate(nullptr, from) {} - IceCandidate(IceCandidate&& from) noexcept - : IceCandidate() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IceCandidate* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IceCandidate)); } +#endif + template + explicit PROTOBUF_CONSTEXPR IceCandidate(::google::protobuf::internal::ConstantInitialized); + + inline IceCandidate(const IceCandidate& from) : IceCandidate(nullptr, from) {} + inline IceCandidate(IceCandidate&& from) noexcept + : IceCandidate(nullptr, ::std::move(from)) {} inline IceCandidate& operator=(const IceCandidate& from) { CopyFrom(from); return *this; } inline IceCandidate& operator=(IceCandidate&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2396,47 +2486,35 @@ class IceCandidate final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const IceCandidate& default_instance() { - return *internal_default_instance(); - } - static inline const IceCandidate* internal_default_instance() { - return reinterpret_cast( - &_IceCandidate_default_instance_); + return *reinterpret_cast( + &_IceCandidate_default_instance_); } - static constexpr int kIndexInFileMessages = - 28; - - friend void swap(IceCandidate& a, IceCandidate& b) { - a.Swap(&b); - } - inline void Swap(IceCandidate* other) { + static constexpr int kIndexInFileMessages = 28; + friend void swap(IceCandidate& a, IceCandidate& b) { a.Swap(&b); } + inline void Swap(IceCandidate* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(IceCandidate* other) { + void UnsafeArenaSwap(IceCandidate* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2444,33 +2522,40 @@ class IceCandidate final : // implements Message ---------------------------------------------- - IceCandidate* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + IceCandidate* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(IceCandidate* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.IceCandidate"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(IceCandidate* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.IceCandidate"; } + + explicit IceCandidate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + IceCandidate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IceCandidate& from); + IceCandidate( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, IceCandidate&& from) noexcept + : IceCandidate(arena) { + *this = ::std::move(from); } - protected: - explicit IceCandidate(::google::protobuf::Arena* arena); - IceCandidate(::google::protobuf::Arena* arena, const IceCandidate& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kCandidateFieldNumber = 1, kMidFieldNumber = 2, @@ -2478,55 +2563,57 @@ class IceCandidate final : }; // string candidate = 1; void clear_candidate() ; - const std::string& candidate() const; - template + const ::std::string& candidate() const; + template void set_candidate(Arg_&& arg, Args_... args); - std::string* mutable_candidate(); - PROTOBUF_NODISCARD std::string* release_candidate(); - void set_allocated_candidate(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_candidate(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_candidate(); + void set_allocated_candidate(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_candidate() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_candidate( - const std::string& value); - std::string* _internal_mutable_candidate(); + const ::std::string& _internal_candidate() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_candidate(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_candidate(); public: // string mid = 2; void clear_mid() ; - const std::string& mid() const; - template + const ::std::string& mid() const; + template void set_mid(Arg_&& arg, Args_... args); - std::string* mutable_mid(); - PROTOBUF_NODISCARD std::string* release_mid(); - void set_allocated_mid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_mid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_mid(); + void set_allocated_mid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_mid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mid( - const std::string& value); - std::string* _internal_mutable_mid(); + const ::std::string& _internal_mid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_mid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_mid(); public: // string connectionId = 3; void clear_connectionid() ; - const std::string& connectionid() const; - template + const ::std::string& connectionid() const; + template void set_connectionid(Arg_&& arg, Args_... args); - std::string* mutable_connectionid(); - PROTOBUF_NODISCARD std::string* release_connectionid(); - void set_allocated_connectionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_connectionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_connectionid(); + void set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_connectionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid( - const std::string& value); - std::string* _internal_mutable_connectionid(); + const ::std::string& _internal_connectionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_connectionid(); public: // @@protoc_insertion_point(class_scope:dht.IceCandidate) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 0, 49, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2535,49 +2622,54 @@ class IceCandidate final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const IceCandidate& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr candidate_; ::google::protobuf::internal::ArenaStringPtr mid_; ::google::protobuf::internal::ArenaStringPtr connectionid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull IceCandidate_class_data_; +// ------------------------------------------------------------------- -class ExternalFetchDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataRequest) */ { +class ExternalFetchDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataRequest) */ { public: inline ExternalFetchDataRequest() : ExternalFetchDataRequest(nullptr) {} - ~ExternalFetchDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR ExternalFetchDataRequest(::google::protobuf::internal::ConstantInitialized); + ~ExternalFetchDataRequest() PROTOBUF_FINAL; - inline ExternalFetchDataRequest(const ExternalFetchDataRequest& from) - : ExternalFetchDataRequest(nullptr, from) {} - ExternalFetchDataRequest(ExternalFetchDataRequest&& from) noexcept - : ExternalFetchDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalFetchDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalFetchDataRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalFetchDataRequest(::google::protobuf::internal::ConstantInitialized); + inline ExternalFetchDataRequest(const ExternalFetchDataRequest& from) : ExternalFetchDataRequest(nullptr, from) {} + inline ExternalFetchDataRequest(ExternalFetchDataRequest&& from) noexcept + : ExternalFetchDataRequest(nullptr, ::std::move(from)) {} inline ExternalFetchDataRequest& operator=(const ExternalFetchDataRequest& from) { CopyFrom(from); return *this; } inline ExternalFetchDataRequest& operator=(ExternalFetchDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2589,47 +2681,35 @@ class ExternalFetchDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalFetchDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalFetchDataRequest* internal_default_instance() { - return reinterpret_cast( - &_ExternalFetchDataRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 33; - - friend void swap(ExternalFetchDataRequest& a, ExternalFetchDataRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ExternalFetchDataRequest_default_instance_); } - inline void Swap(ExternalFetchDataRequest* other) { + static constexpr int kIndexInFileMessages = 33; + friend void swap(ExternalFetchDataRequest& a, ExternalFetchDataRequest& b) { a.Swap(&b); } + inline void Swap(ExternalFetchDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalFetchDataRequest* other) { + void UnsafeArenaSwap(ExternalFetchDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2637,55 +2717,66 @@ class ExternalFetchDataRequest final : // implements Message ---------------------------------------------- - ExternalFetchDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalFetchDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalFetchDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalFetchDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalFetchDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalFetchDataRequest"; } + + explicit ExternalFetchDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalFetchDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataRequest& from); + ExternalFetchDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalFetchDataRequest&& from) noexcept + : ExternalFetchDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalFetchDataRequest(::google::protobuf::Arena* arena); - ExternalFetchDataRequest(::google::protobuf::Arena* arena, const ExternalFetchDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // @@protoc_insertion_point(class_scope:dht.ExternalFetchDataRequest) 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; @@ -2694,47 +2785,52 @@ class ExternalFetchDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalFetchDataRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class DisconnectNotice final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.DisconnectNotice) */ { +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataRequest_class_data_; +// ------------------------------------------------------------------- + +class DisconnectNotice final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.DisconnectNotice) */ { public: inline DisconnectNotice() : DisconnectNotice(nullptr) {} - ~DisconnectNotice() override; - template - explicit PROTOBUF_CONSTEXPR DisconnectNotice(::google::protobuf::internal::ConstantInitialized); + ~DisconnectNotice() PROTOBUF_FINAL; - inline DisconnectNotice(const DisconnectNotice& from) - : DisconnectNotice(nullptr, from) {} - DisconnectNotice(DisconnectNotice&& from) noexcept - : DisconnectNotice() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DisconnectNotice* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DisconnectNotice)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR DisconnectNotice(::google::protobuf::internal::ConstantInitialized); + inline DisconnectNotice(const DisconnectNotice& from) : DisconnectNotice(nullptr, from) {} + inline DisconnectNotice(DisconnectNotice&& from) noexcept + : DisconnectNotice(nullptr, ::std::move(from)) {} inline DisconnectNotice& operator=(const DisconnectNotice& from) { CopyFrom(from); return *this; } inline DisconnectNotice& operator=(DisconnectNotice&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2746,47 +2842,35 @@ class DisconnectNotice final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const DisconnectNotice& default_instance() { - return *internal_default_instance(); - } - static inline const DisconnectNotice* internal_default_instance() { - return reinterpret_cast( - &_DisconnectNotice_default_instance_); + return *reinterpret_cast( + &_DisconnectNotice_default_instance_); } - static constexpr int kIndexInFileMessages = - 32; - - friend void swap(DisconnectNotice& a, DisconnectNotice& b) { - a.Swap(&b); - } - inline void Swap(DisconnectNotice* other) { + static constexpr int kIndexInFileMessages = 32; + friend void swap(DisconnectNotice& a, DisconnectNotice& b) { a.Swap(&b); } + inline void Swap(DisconnectNotice* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(DisconnectNotice* other) { + void UnsafeArenaSwap(DisconnectNotice* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2794,33 +2878,40 @@ class DisconnectNotice final : // implements Message ---------------------------------------------- - DisconnectNotice* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + DisconnectNotice* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(DisconnectNotice* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.DisconnectNotice"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(DisconnectNotice* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.DisconnectNotice"; } + + explicit DisconnectNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + DisconnectNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DisconnectNotice& from); + DisconnectNotice( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DisconnectNotice&& from) noexcept + : DisconnectNotice(arena) { + *this = ::std::move(from); } - protected: - explicit DisconnectNotice(::google::protobuf::Arena* arena); - DisconnectNotice(::google::protobuf::Arena* arena, const DisconnectNotice& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kDisconnectModeFieldNumber = 1, }; @@ -2837,6 +2928,11 @@ class DisconnectNotice final : // @@protoc_insertion_point(class_scope:dht.DisconnectNotice) 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; @@ -2845,47 +2941,52 @@ class DisconnectNotice final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const DisconnectNotice& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; int disconnectmode_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull DisconnectNotice_class_data_; +// ------------------------------------------------------------------- -class ConnectivityRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ConnectivityRequest) */ { +class ConnectivityRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ConnectivityRequest) */ { public: inline ConnectivityRequest() : ConnectivityRequest(nullptr) {} - ~ConnectivityRequest() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityRequest(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityRequest() PROTOBUF_FINAL; - inline ConnectivityRequest(const ConnectivityRequest& from) - : ConnectivityRequest(nullptr, from) {} - ConnectivityRequest(ConnectivityRequest&& from) noexcept - : ConnectivityRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConnectivityRequest(::google::protobuf::internal::ConstantInitialized); + inline ConnectivityRequest(const ConnectivityRequest& from) : ConnectivityRequest(nullptr, from) {} + inline ConnectivityRequest(ConnectivityRequest&& from) noexcept + : ConnectivityRequest(nullptr, ::std::move(from)) {} inline ConnectivityRequest& operator=(const ConnectivityRequest& from) { CopyFrom(from); return *this; } inline ConnectivityRequest& operator=(ConnectivityRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2897,47 +2998,35 @@ class ConnectivityRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ConnectivityRequest* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(ConnectivityRequest& a, ConnectivityRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ConnectivityRequest_default_instance_); } - inline void Swap(ConnectivityRequest* other) { + static constexpr int kIndexInFileMessages = 19; + friend void swap(ConnectivityRequest& a, ConnectivityRequest& b) { a.Swap(&b); } + inline void Swap(ConnectivityRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityRequest* other) { + void UnsafeArenaSwap(ConnectivityRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2945,33 +3034,40 @@ class ConnectivityRequest final : // implements Message ---------------------------------------------- - ConnectivityRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ConnectivityRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ConnectivityRequest"; } + + explicit ConnectivityRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityRequest& from); + ConnectivityRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityRequest&& from) noexcept + : ConnectivityRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityRequest(::google::protobuf::Arena* arena); - ConnectivityRequest(::google::protobuf::Arena* arena, const ConnectivityRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kHostFieldNumber = 3, kPortFieldNumber = 1, @@ -2981,18 +3077,17 @@ class ConnectivityRequest final : // optional string host = 3; bool has_host() const; void clear_host() ; - const std::string& host() const; - template + const ::std::string& host() const; + template void set_host(Arg_&& arg, Args_... args); - std::string* mutable_host(); - PROTOBUF_NODISCARD std::string* release_host(); - void set_allocated_host(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_host(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host(); + void set_allocated_host(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_host() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( - const std::string& value); - std::string* _internal_mutable_host(); + const ::std::string& _internal_host() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_host(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_host(); public: // uint32 port = 1; @@ -3028,6 +3123,11 @@ class ConnectivityRequest final : // @@protoc_insertion_point(class_scope:dht.ConnectivityRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 0, 36, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3036,15 +3136,16 @@ class ConnectivityRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr host_; ::uint32_t port_; bool tls_; @@ -3053,34 +3154,37 @@ class ConnectivityRequest final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class ConnectivityMethod final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ConnectivityMethod) */ { +extern const ::google::protobuf::internal::ClassDataFull ConnectivityRequest_class_data_; +// ------------------------------------------------------------------- + +class ConnectivityMethod final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ConnectivityMethod) */ { public: inline ConnectivityMethod() : ConnectivityMethod(nullptr) {} - ~ConnectivityMethod() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityMethod(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityMethod() PROTOBUF_FINAL; - inline ConnectivityMethod(const ConnectivityMethod& from) - : ConnectivityMethod(nullptr, from) {} - ConnectivityMethod(ConnectivityMethod&& from) noexcept - : ConnectivityMethod() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityMethod* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityMethod)); } +#endif + template + explicit PROTOBUF_CONSTEXPR ConnectivityMethod(::google::protobuf::internal::ConstantInitialized); + + inline ConnectivityMethod(const ConnectivityMethod& from) : ConnectivityMethod(nullptr, from) {} + inline ConnectivityMethod(ConnectivityMethod&& from) noexcept + : ConnectivityMethod(nullptr, ::std::move(from)) {} inline ConnectivityMethod& operator=(const ConnectivityMethod& from) { CopyFrom(from); return *this; } inline ConnectivityMethod& operator=(ConnectivityMethod&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3092,47 +3196,35 @@ class ConnectivityMethod final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityMethod& default_instance() { - return *internal_default_instance(); - } - static inline const ConnectivityMethod* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityMethod_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(ConnectivityMethod& a, ConnectivityMethod& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ConnectivityMethod_default_instance_); } - inline void Swap(ConnectivityMethod* other) { + static constexpr int kIndexInFileMessages = 16; + friend void swap(ConnectivityMethod& a, ConnectivityMethod& b) { a.Swap(&b); } + inline void Swap(ConnectivityMethod* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityMethod* other) { + void UnsafeArenaSwap(ConnectivityMethod* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3140,33 +3232,40 @@ class ConnectivityMethod final : // implements Message ---------------------------------------------- - ConnectivityMethod* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityMethod* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityMethod* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ConnectivityMethod"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityMethod* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ConnectivityMethod"; } + + explicit ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityMethod& from); + ConnectivityMethod( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityMethod&& from) noexcept + : ConnectivityMethod(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityMethod(::google::protobuf::Arena* arena); - ConnectivityMethod(::google::protobuf::Arena* arena, const ConnectivityMethod& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kHostFieldNumber = 2, kPortFieldNumber = 1, @@ -3174,18 +3273,17 @@ class ConnectivityMethod final : }; // string host = 2; void clear_host() ; - const std::string& host() const; - template + const ::std::string& host() const; + template void set_host(Arg_&& arg, Args_... args); - std::string* mutable_host(); - PROTOBUF_NODISCARD std::string* release_host(); - void set_allocated_host(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_host(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host(); + void set_allocated_host(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_host() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( - const std::string& value); - std::string* _internal_mutable_host(); + const ::std::string& _internal_host() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_host(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_host(); public: // uint32 port = 1; @@ -3211,6 +3309,11 @@ class ConnectivityMethod final : // @@protoc_insertion_point(class_scope:dht.ConnectivityMethod) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 0, 35, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3219,49 +3322,54 @@ class ConnectivityMethod final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityMethod& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr host_; ::uint32_t port_; bool tls_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class ClosestRingPeersRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_; +// ------------------------------------------------------------------- + +class ClosestRingPeersRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersRequest) */ { public: inline ClosestRingPeersRequest() : ClosestRingPeersRequest(nullptr) {} - ~ClosestRingPeersRequest() override; - template - explicit PROTOBUF_CONSTEXPR ClosestRingPeersRequest(::google::protobuf::internal::ConstantInitialized); + ~ClosestRingPeersRequest() PROTOBUF_FINAL; - inline ClosestRingPeersRequest(const ClosestRingPeersRequest& from) - : ClosestRingPeersRequest(nullptr, from) {} - ClosestRingPeersRequest(ClosestRingPeersRequest&& from) noexcept - : ClosestRingPeersRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestRingPeersRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestRingPeersRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestRingPeersRequest(::google::protobuf::internal::ConstantInitialized); + inline ClosestRingPeersRequest(const ClosestRingPeersRequest& from) : ClosestRingPeersRequest(nullptr, from) {} + inline ClosestRingPeersRequest(ClosestRingPeersRequest&& from) noexcept + : ClosestRingPeersRequest(nullptr, ::std::move(from)) {} inline ClosestRingPeersRequest& operator=(const ClosestRingPeersRequest& from) { CopyFrom(from); return *this; } inline ClosestRingPeersRequest& operator=(ClosestRingPeersRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3273,47 +3381,35 @@ class ClosestRingPeersRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestRingPeersRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestRingPeersRequest* internal_default_instance() { - return reinterpret_cast( - &_ClosestRingPeersRequest_default_instance_); + return *reinterpret_cast( + &_ClosestRingPeersRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(ClosestRingPeersRequest& a, ClosestRingPeersRequest& b) { - a.Swap(&b); - } - inline void Swap(ClosestRingPeersRequest* other) { + static constexpr int kIndexInFileMessages = 8; + friend void swap(ClosestRingPeersRequest& a, ClosestRingPeersRequest& b) { a.Swap(&b); } + inline void Swap(ClosestRingPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestRingPeersRequest* other) { + void UnsafeArenaSwap(ClosestRingPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3321,72 +3417,82 @@ class ClosestRingPeersRequest final : // implements Message ---------------------------------------------- - ClosestRingPeersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestRingPeersRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestRingPeersRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestRingPeersRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestRingPeersRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestRingPeersRequest"; } + + explicit ClosestRingPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestRingPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersRequest& from); + ClosestRingPeersRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestRingPeersRequest&& from) noexcept + : ClosestRingPeersRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestRingPeersRequest(::google::protobuf::Arena* arena); - ClosestRingPeersRequest(::google::protobuf::Arena* arena, const ClosestRingPeersRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRingIdFieldNumber = 1, kRequestIdFieldNumber = 2, }; // bytes ringId = 1; void clear_ringid() ; - const std::string& ringid() const; - template + const ::std::string& ringid() const; + template void set_ringid(Arg_&& arg, Args_... args); - std::string* mutable_ringid(); - PROTOBUF_NODISCARD std::string* release_ringid(); - void set_allocated_ringid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_ringid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ringid(); + void set_allocated_ringid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_ringid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ringid( - const std::string& value); - std::string* _internal_mutable_ringid(); + const ::std::string& _internal_ringid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_ringid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_ringid(); public: // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestRingPeersRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 45, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3395,48 +3501,53 @@ class ClosestRingPeersRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestRingPeersRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr ringid_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersRequest_class_data_; +// ------------------------------------------------------------------- -class ClosestPeersRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestPeersRequest) */ { +class ClosestPeersRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestPeersRequest) */ { public: inline ClosestPeersRequest() : ClosestPeersRequest(nullptr) {} - ~ClosestPeersRequest() override; - template - explicit PROTOBUF_CONSTEXPR ClosestPeersRequest(::google::protobuf::internal::ConstantInitialized); + ~ClosestPeersRequest() PROTOBUF_FINAL; - inline ClosestPeersRequest(const ClosestPeersRequest& from) - : ClosestPeersRequest(nullptr, from) {} - ClosestPeersRequest(ClosestPeersRequest&& from) noexcept - : ClosestPeersRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestPeersRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestPeersRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestPeersRequest(::google::protobuf::internal::ConstantInitialized); + inline ClosestPeersRequest(const ClosestPeersRequest& from) : ClosestPeersRequest(nullptr, from) {} + inline ClosestPeersRequest(ClosestPeersRequest&& from) noexcept + : ClosestPeersRequest(nullptr, ::std::move(from)) {} inline ClosestPeersRequest& operator=(const ClosestPeersRequest& from) { CopyFrom(from); return *this; } inline ClosestPeersRequest& operator=(ClosestPeersRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3448,47 +3559,35 @@ class ClosestPeersRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestPeersRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestPeersRequest* internal_default_instance() { - return reinterpret_cast( - &_ClosestPeersRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(ClosestPeersRequest& a, ClosestPeersRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ClosestPeersRequest_default_instance_); } - inline void Swap(ClosestPeersRequest* other) { + static constexpr int kIndexInFileMessages = 6; + friend void swap(ClosestPeersRequest& a, ClosestPeersRequest& b) { a.Swap(&b); } + inline void Swap(ClosestPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestPeersRequest* other) { + void UnsafeArenaSwap(ClosestPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3496,72 +3595,82 @@ class ClosestPeersRequest final : // implements Message ---------------------------------------------- - ClosestPeersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestPeersRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestPeersRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestPeersRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestPeersRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestPeersRequest"; } + + explicit ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersRequest& from); + ClosestPeersRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestPeersRequest&& from) noexcept + : ClosestPeersRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestPeersRequest(::google::protobuf::Arena* arena); - ClosestPeersRequest(::google::protobuf::Arena* arena, const ClosestPeersRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNodeIdFieldNumber = 1, kRequestIdFieldNumber = 2, }; // bytes nodeId = 1; void clear_nodeid() ; - const std::string& nodeid() const; - template + const ::std::string& nodeid() const; + template void set_nodeid(Arg_&& arg, Args_... args); - std::string* mutable_nodeid(); - PROTOBUF_NODISCARD std::string* release_nodeid(); - void set_allocated_nodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nodeid(); + void set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid( - const std::string& value); - std::string* _internal_mutable_nodeid(); + const ::std::string& _internal_nodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nodeid(); public: // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestPeersRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 41, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3570,48 +3679,53 @@ class ClosestPeersRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestPeersRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr nodeid_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class StoreDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.StoreDataRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_; +// ------------------------------------------------------------------- + +class StoreDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.StoreDataRequest) */ { public: inline StoreDataRequest() : StoreDataRequest(nullptr) {} - ~StoreDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR StoreDataRequest(::google::protobuf::internal::ConstantInitialized); + ~StoreDataRequest() PROTOBUF_FINAL; - inline StoreDataRequest(const StoreDataRequest& from) - : StoreDataRequest(nullptr, from) {} - StoreDataRequest(StoreDataRequest&& from) noexcept - : StoreDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StoreDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StoreDataRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR StoreDataRequest(::google::protobuf::internal::ConstantInitialized); + + inline StoreDataRequest(const StoreDataRequest& from) : StoreDataRequest(nullptr, from) {} + inline StoreDataRequest(StoreDataRequest&& from) noexcept + : StoreDataRequest(nullptr, ::std::move(from)) {} inline StoreDataRequest& operator=(const StoreDataRequest& from) { CopyFrom(from); return *this; } inline StoreDataRequest& operator=(StoreDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3623,47 +3737,35 @@ class StoreDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StoreDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const StoreDataRequest* internal_default_instance() { - return reinterpret_cast( - &_StoreDataRequest_default_instance_); + return *reinterpret_cast( + &_StoreDataRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(StoreDataRequest& a, StoreDataRequest& b) { - a.Swap(&b); - } - inline void Swap(StoreDataRequest* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(StoreDataRequest& a, StoreDataRequest& b) { a.Swap(&b); } + inline void Swap(StoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StoreDataRequest* other) { + void UnsafeArenaSwap(StoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3671,33 +3773,40 @@ class StoreDataRequest final : // implements Message ---------------------------------------------- - StoreDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StoreDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(StoreDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.StoreDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(StoreDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.StoreDataRequest"; } + + explicit StoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataRequest& from); + StoreDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StoreDataRequest&& from) noexcept + : StoreDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit StoreDataRequest(::google::protobuf::Arena* arena); - StoreDataRequest(::google::protobuf::Arena* arena, const StoreDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, kCreatorFieldNumber = 3, @@ -3707,64 +3816,62 @@ class StoreDataRequest final : }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // bytes creator = 3; void clear_creator() ; - const std::string& creator() const; - template + const ::std::string& creator() const; + template void set_creator(Arg_&& arg, Args_... args); - std::string* mutable_creator(); - PROTOBUF_NODISCARD std::string* release_creator(); - void set_allocated_creator(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_creator(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_creator(); + void set_allocated_creator(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_creator() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_creator( - const std::string& value); - std::string* _internal_mutable_creator(); + const ::std::string& _internal_creator() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_creator(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_creator(); public: // .google.protobuf.Any data = 2; bool has_data() const; void clear_data() ; const ::google::protobuf::Any& data() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); - ::google::protobuf::Any* mutable_data(); - void set_allocated_data(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_data(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_data(); + void set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_data(); private: const ::google::protobuf::Any& _internal_data() const; - ::google::protobuf::Any* _internal_mutable_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_data(); public: // .google.protobuf.Timestamp createdAt = 4; bool has_createdat() const; void clear_createdat() ; const ::google::protobuf::Timestamp& createdat() const; - PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_createdat(); - ::google::protobuf::Timestamp* mutable_createdat(); - void set_allocated_createdat(::google::protobuf::Timestamp* value); - void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value); - ::google::protobuf::Timestamp* unsafe_arena_release_createdat(); + [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_createdat(); + void set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_createdat(); private: const ::google::protobuf::Timestamp& _internal_createdat() const; - ::google::protobuf::Timestamp* _internal_mutable_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_createdat(); public: // uint32 ttl = 5; @@ -3780,6 +3887,11 @@ class StoreDataRequest final : // @@protoc_insertion_point(class_scope:dht.StoreDataRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 2, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3788,52 +3900,56 @@ class StoreDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const StoreDataRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; ::google::protobuf::internal::ArenaStringPtr creator_; - ::google::protobuf::Any* data_; - ::google::protobuf::Timestamp* createdat_; + ::google::protobuf::Any* PROTOBUF_NULLABLE data_; + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE createdat_; ::uint32_t ttl_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StoreDataRequest_class_data_; +// ------------------------------------------------------------------- -class PeerDescriptor final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.PeerDescriptor) */ { +class PeerDescriptor final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.PeerDescriptor) */ { public: inline PeerDescriptor() : PeerDescriptor(nullptr) {} - ~PeerDescriptor() override; - template - explicit PROTOBUF_CONSTEXPR PeerDescriptor(::google::protobuf::internal::ConstantInitialized); + ~PeerDescriptor() PROTOBUF_FINAL; - inline PeerDescriptor(const PeerDescriptor& from) - : PeerDescriptor(nullptr, from) {} - PeerDescriptor(PeerDescriptor&& from) noexcept - : PeerDescriptor() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PeerDescriptor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PeerDescriptor)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR PeerDescriptor(::google::protobuf::internal::ConstantInitialized); + inline PeerDescriptor(const PeerDescriptor& from) : PeerDescriptor(nullptr, from) {} + inline PeerDescriptor(PeerDescriptor&& from) noexcept + : PeerDescriptor(nullptr, ::std::move(from)) {} inline PeerDescriptor& operator=(const PeerDescriptor& from) { CopyFrom(from); return *this; } inline PeerDescriptor& operator=(PeerDescriptor&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3845,47 +3961,35 @@ class PeerDescriptor final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerDescriptor& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_PeerDescriptor_default_instance_); } - static inline const PeerDescriptor* internal_default_instance() { - return reinterpret_cast( - &_PeerDescriptor_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(PeerDescriptor& a, PeerDescriptor& b) { - a.Swap(&b); - } - inline void Swap(PeerDescriptor* other) { + static constexpr int kIndexInFileMessages = 15; + friend void swap(PeerDescriptor& a, PeerDescriptor& b) { a.Swap(&b); } + inline void Swap(PeerDescriptor* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PeerDescriptor* other) { + void UnsafeArenaSwap(PeerDescriptor* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3893,33 +3997,40 @@ class PeerDescriptor final : // implements Message ---------------------------------------------- - PeerDescriptor* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PeerDescriptor* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PeerDescriptor* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.PeerDescriptor"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PeerDescriptor* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.PeerDescriptor"; } + + explicit PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PeerDescriptor& from); + PeerDescriptor( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PeerDescriptor&& from) noexcept + : PeerDescriptor(arena) { + *this = ::std::move(from); } - protected: - explicit PeerDescriptor(::google::protobuf::Arena* arena); - PeerDescriptor(::google::protobuf::Arena* arena, const PeerDescriptor& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNodeIdFieldNumber = 1, kPublicKeyFieldNumber = 8, @@ -3933,97 +4044,94 @@ class PeerDescriptor final : }; // bytes nodeId = 1; void clear_nodeid() ; - const std::string& nodeid() const; - template + const ::std::string& nodeid() const; + template void set_nodeid(Arg_&& arg, Args_... args); - std::string* mutable_nodeid(); - PROTOBUF_NODISCARD std::string* release_nodeid(); - void set_allocated_nodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nodeid(); + void set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid( - const std::string& value); - std::string* _internal_mutable_nodeid(); + const ::std::string& _internal_nodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nodeid(); public: // optional bytes publicKey = 8; bool has_publickey() const; void clear_publickey() ; - const std::string& publickey() const; - template + const ::std::string& publickey() const; + template void set_publickey(Arg_&& arg, Args_... args); - std::string* mutable_publickey(); - PROTOBUF_NODISCARD std::string* release_publickey(); - void set_allocated_publickey(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_publickey(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_publickey(); + void set_allocated_publickey(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_publickey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey( - const std::string& value); - std::string* _internal_mutable_publickey(); + const ::std::string& _internal_publickey() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_publickey(); public: // optional bytes signature = 9; bool has_signature() const; void clear_signature() ; - const std::string& signature() const; - template + const ::std::string& signature() const; + template void set_signature(Arg_&& arg, Args_... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_signature(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_signature(); + void set_allocated_signature(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature( - const std::string& value); - std::string* _internal_mutable_signature(); + const ::std::string& _internal_signature() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_signature(); public: // .dht.ConnectivityMethod udp = 3; bool has_udp() const; void clear_udp() ; const ::dht::ConnectivityMethod& udp() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_udp(); - ::dht::ConnectivityMethod* mutable_udp(); - void set_allocated_udp(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_udp(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_udp(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_udp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_udp(); + void set_allocated_udp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_udp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_udp(); private: const ::dht::ConnectivityMethod& _internal_udp() const; - ::dht::ConnectivityMethod* _internal_mutable_udp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_udp(); public: // .dht.ConnectivityMethod tcp = 4; bool has_tcp() const; void clear_tcp() ; const ::dht::ConnectivityMethod& tcp() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_tcp(); - ::dht::ConnectivityMethod* mutable_tcp(); - void set_allocated_tcp(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_tcp(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_tcp(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_tcp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_tcp(); + void set_allocated_tcp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_tcp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_tcp(); private: const ::dht::ConnectivityMethod& _internal_tcp() const; - ::dht::ConnectivityMethod* _internal_mutable_tcp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_tcp(); public: // .dht.ConnectivityMethod websocket = 5; bool has_websocket() const; void clear_websocket() ; const ::dht::ConnectivityMethod& websocket() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_websocket(); - ::dht::ConnectivityMethod* mutable_websocket(); - void set_allocated_websocket(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_websocket(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_websocket(); + void set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_websocket(); private: const ::dht::ConnectivityMethod& _internal_websocket() const; - ::dht::ConnectivityMethod* _internal_mutable_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_websocket(); public: // .dht.NodeType type = 2; @@ -4061,6 +4169,11 @@ class PeerDescriptor final : // @@protoc_insertion_point(class_scope:dht.PeerDescriptor) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<4, 9, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4069,21 +4182,22 @@ class PeerDescriptor final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PeerDescriptor& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr nodeid_; ::google::protobuf::internal::ArenaStringPtr publickey_; ::google::protobuf::internal::ArenaStringPtr signature_; - ::dht::ConnectivityMethod* udp_; - ::dht::ConnectivityMethod* tcp_; - ::dht::ConnectivityMethod* websocket_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE udp_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE tcp_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE websocket_; int type_; ::uint32_t region_; ::uint32_t ipaddress_; @@ -4091,34 +4205,37 @@ class PeerDescriptor final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_; +// ------------------------------------------------------------------- -class ExternalStoreDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataRequest) */ { +class ExternalStoreDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataRequest) */ { public: inline ExternalStoreDataRequest() : ExternalStoreDataRequest(nullptr) {} - ~ExternalStoreDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR ExternalStoreDataRequest(::google::protobuf::internal::ConstantInitialized); + ~ExternalStoreDataRequest() PROTOBUF_FINAL; - inline ExternalStoreDataRequest(const ExternalStoreDataRequest& from) - : ExternalStoreDataRequest(nullptr, from) {} - ExternalStoreDataRequest(ExternalStoreDataRequest&& from) noexcept - : ExternalStoreDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalStoreDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalStoreDataRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalStoreDataRequest(::google::protobuf::internal::ConstantInitialized); + inline ExternalStoreDataRequest(const ExternalStoreDataRequest& from) : ExternalStoreDataRequest(nullptr, from) {} + inline ExternalStoreDataRequest(ExternalStoreDataRequest&& from) noexcept + : ExternalStoreDataRequest(nullptr, ::std::move(from)) {} inline ExternalStoreDataRequest& operator=(const ExternalStoreDataRequest& from) { CopyFrom(from); return *this; } inline ExternalStoreDataRequest& operator=(ExternalStoreDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4130,47 +4247,35 @@ class ExternalStoreDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalStoreDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalStoreDataRequest* internal_default_instance() { - return reinterpret_cast( - &_ExternalStoreDataRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(ExternalStoreDataRequest& a, ExternalStoreDataRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ExternalStoreDataRequest_default_instance_); } - inline void Swap(ExternalStoreDataRequest* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(ExternalStoreDataRequest& a, ExternalStoreDataRequest& b) { a.Swap(&b); } + inline void Swap(ExternalStoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalStoreDataRequest* other) { + void UnsafeArenaSwap(ExternalStoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4178,71 +4283,82 @@ class ExternalStoreDataRequest final : // implements Message ---------------------------------------------- - ExternalStoreDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalStoreDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalStoreDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalStoreDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalStoreDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalStoreDataRequest"; } + + explicit ExternalStoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalStoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataRequest& from); + ExternalStoreDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalStoreDataRequest&& from) noexcept + : ExternalStoreDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalStoreDataRequest(::google::protobuf::Arena* arena); - ExternalStoreDataRequest(::google::protobuf::Arena* arena, const ExternalStoreDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, kDataFieldNumber = 2, }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // .google.protobuf.Any data = 2; bool has_data() const; void clear_data() ; const ::google::protobuf::Any& data() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); - ::google::protobuf::Any* mutable_data(); - void set_allocated_data(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_data(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_data(); + void set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_data(); private: const ::google::protobuf::Any& _internal_data() const; - ::google::protobuf::Any* _internal_mutable_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_data(); public: // @@protoc_insertion_point(class_scope:dht.ExternalStoreDataRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4251,49 +4367,53 @@ class ExternalStoreDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalStoreDataRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; - ::google::protobuf::Any* data_; + ::google::protobuf::Any* PROTOBUF_NULLABLE data_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataRequest_class_data_; +// ------------------------------------------------------------------- -class DataEntry final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.DataEntry) */ { +class DataEntry final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.DataEntry) */ { public: inline DataEntry() : DataEntry(nullptr) {} - ~DataEntry() override; - template - explicit PROTOBUF_CONSTEXPR DataEntry(::google::protobuf::internal::ConstantInitialized); + ~DataEntry() PROTOBUF_FINAL; - inline DataEntry(const DataEntry& from) - : DataEntry(nullptr, from) {} - DataEntry(DataEntry&& from) noexcept - : DataEntry() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DataEntry* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DataEntry)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR DataEntry(::google::protobuf::internal::ConstantInitialized); + inline DataEntry(const DataEntry& from) : DataEntry(nullptr, from) {} + inline DataEntry(DataEntry&& from) noexcept + : DataEntry(nullptr, ::std::move(from)) {} inline DataEntry& operator=(const DataEntry& from) { CopyFrom(from); return *this; } inline DataEntry& operator=(DataEntry&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4305,47 +4425,35 @@ class DataEntry final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const DataEntry& default_instance() { - return *internal_default_instance(); - } - static inline const DataEntry* internal_default_instance() { - return reinterpret_cast( - &_DataEntry_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(DataEntry& a, DataEntry& b) { - a.Swap(&b); + return *reinterpret_cast( + &_DataEntry_default_instance_); } - inline void Swap(DataEntry* other) { + static constexpr int kIndexInFileMessages = 5; + friend void swap(DataEntry& a, DataEntry& b) { a.Swap(&b); } + inline void Swap(DataEntry* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(DataEntry* other) { + void UnsafeArenaSwap(DataEntry* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4353,33 +4461,40 @@ class DataEntry final : // implements Message ---------------------------------------------- - DataEntry* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + DataEntry* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(DataEntry* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.DataEntry"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(DataEntry* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.DataEntry"; } + + explicit DataEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + DataEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DataEntry& from); + DataEntry( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DataEntry&& from) noexcept + : DataEntry(arena) { + *this = ::std::move(from); } - protected: - explicit DataEntry(::google::protobuf::Arena* arena); - DataEntry(::google::protobuf::Arena* arena, const DataEntry& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, kCreatorFieldNumber = 3, @@ -4392,79 +4507,77 @@ class DataEntry final : }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // bytes creator = 3; void clear_creator() ; - const std::string& creator() const; - template + const ::std::string& creator() const; + template void set_creator(Arg_&& arg, Args_... args); - std::string* mutable_creator(); - PROTOBUF_NODISCARD std::string* release_creator(); - void set_allocated_creator(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_creator(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_creator(); + void set_allocated_creator(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_creator() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_creator( - const std::string& value); - std::string* _internal_mutable_creator(); + const ::std::string& _internal_creator() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_creator(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_creator(); public: // .google.protobuf.Any data = 2; bool has_data() const; void clear_data() ; const ::google::protobuf::Any& data() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); - ::google::protobuf::Any* mutable_data(); - void set_allocated_data(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_data(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_data(); + void set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_data(); private: const ::google::protobuf::Any& _internal_data() const; - ::google::protobuf::Any* _internal_mutable_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_data(); public: // .google.protobuf.Timestamp createdAt = 4; bool has_createdat() const; void clear_createdat() ; const ::google::protobuf::Timestamp& createdat() const; - PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_createdat(); - ::google::protobuf::Timestamp* mutable_createdat(); - void set_allocated_createdat(::google::protobuf::Timestamp* value); - void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value); - ::google::protobuf::Timestamp* unsafe_arena_release_createdat(); + [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_createdat(); + void set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_createdat(); private: const ::google::protobuf::Timestamp& _internal_createdat() const; - ::google::protobuf::Timestamp* _internal_mutable_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_createdat(); public: // .google.protobuf.Timestamp storedAt = 5; bool has_storedat() const; void clear_storedat() ; const ::google::protobuf::Timestamp& storedat() const; - PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_storedat(); - ::google::protobuf::Timestamp* mutable_storedat(); - void set_allocated_storedat(::google::protobuf::Timestamp* value); - void unsafe_arena_set_allocated_storedat(::google::protobuf::Timestamp* value); - ::google::protobuf::Timestamp* unsafe_arena_release_storedat(); + [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_storedat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_storedat(); + void set_allocated_storedat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_storedat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_storedat(); private: const ::google::protobuf::Timestamp& _internal_storedat() const; - ::google::protobuf::Timestamp* _internal_mutable_storedat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_storedat(); public: // uint32 ttl = 6; @@ -4500,6 +4613,11 @@ class DataEntry final : // @@protoc_insertion_point(class_scope:dht.DataEntry) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 8, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4508,20 +4626,21 @@ class DataEntry final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const DataEntry& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; ::google::protobuf::internal::ArenaStringPtr creator_; - ::google::protobuf::Any* data_; - ::google::protobuf::Timestamp* createdat_; - ::google::protobuf::Timestamp* storedat_; + ::google::protobuf::Any* PROTOBUF_NULLABLE data_; + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE createdat_; + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE storedat_; ::uint32_t ttl_; bool stale_; bool deleted_; @@ -4529,34 +4648,37 @@ class DataEntry final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull DataEntry_class_data_; +// ------------------------------------------------------------------- -class ConnectivityResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ConnectivityResponse) */ { +class ConnectivityResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ConnectivityResponse) */ { public: inline ConnectivityResponse() : ConnectivityResponse(nullptr) {} - ~ConnectivityResponse() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityResponse(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityResponse() PROTOBUF_FINAL; - inline ConnectivityResponse(const ConnectivityResponse& from) - : ConnectivityResponse(nullptr, from) {} - ConnectivityResponse(ConnectivityResponse&& from) noexcept - : ConnectivityResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConnectivityResponse(::google::protobuf::internal::ConstantInitialized); + inline ConnectivityResponse(const ConnectivityResponse& from) : ConnectivityResponse(nullptr, from) {} + inline ConnectivityResponse(ConnectivityResponse&& from) noexcept + : ConnectivityResponse(nullptr, ::std::move(from)) {} inline ConnectivityResponse& operator=(const ConnectivityResponse& from) { CopyFrom(from); return *this; } inline ConnectivityResponse& operator=(ConnectivityResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4568,47 +4690,35 @@ class ConnectivityResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ConnectivityResponse_default_instance_); } - static inline const ConnectivityResponse* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(ConnectivityResponse& a, ConnectivityResponse& b) { - a.Swap(&b); - } - inline void Swap(ConnectivityResponse* other) { + static constexpr int kIndexInFileMessages = 20; + friend void swap(ConnectivityResponse& a, ConnectivityResponse& b) { a.Swap(&b); } + inline void Swap(ConnectivityResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityResponse* other) { + void UnsafeArenaSwap(ConnectivityResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4616,33 +4726,40 @@ class ConnectivityResponse final : // implements Message ---------------------------------------------- - ConnectivityResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ConnectivityResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ConnectivityResponse"; } + + explicit ConnectivityResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityResponse& from); + ConnectivityResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityResponse&& from) noexcept + : ConnectivityResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityResponse(::google::protobuf::Arena* arena); - ConnectivityResponse(::google::protobuf::Arena* arena, const ConnectivityResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kHostFieldNumber = 1, kNatTypeFieldNumber = 2, @@ -4654,65 +4771,62 @@ class ConnectivityResponse final : }; // string host = 1; void clear_host() ; - const std::string& host() const; - template + const ::std::string& host() const; + template void set_host(Arg_&& arg, Args_... args); - std::string* mutable_host(); - PROTOBUF_NODISCARD std::string* release_host(); - void set_allocated_host(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_host(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host(); + void set_allocated_host(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_host() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( - const std::string& value); - std::string* _internal_mutable_host(); + const ::std::string& _internal_host() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_host(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_host(); public: // string natType = 2; void clear_nattype() ; - const std::string& nattype() const; - template + const ::std::string& nattype() const; + template void set_nattype(Arg_&& arg, Args_... args); - std::string* mutable_nattype(); - PROTOBUF_NODISCARD std::string* release_nattype(); - void set_allocated_nattype(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nattype(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nattype(); + void set_allocated_nattype(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nattype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nattype( - const std::string& value); - std::string* _internal_mutable_nattype(); + const ::std::string& _internal_nattype() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nattype(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nattype(); public: // string version = 5; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.ConnectivityMethod websocket = 3; bool has_websocket() const; void clear_websocket() ; const ::dht::ConnectivityMethod& websocket() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_websocket(); - ::dht::ConnectivityMethod* mutable_websocket(); - void set_allocated_websocket(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_websocket(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_websocket(); + void set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_websocket(); private: const ::dht::ConnectivityMethod& _internal_websocket() const; - ::dht::ConnectivityMethod* _internal_mutable_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_websocket(); public: // optional double latitude = 6; @@ -4750,6 +4864,11 @@ class ConnectivityResponse final : // @@protoc_insertion_point(class_scope:dht.ConnectivityResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 1, 51, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4758,19 +4877,20 @@ class ConnectivityResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr host_; ::google::protobuf::internal::ArenaStringPtr nattype_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::ConnectivityMethod* websocket_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE websocket_; double latitude_; double longitude_; ::uint32_t ipaddress_; @@ -4778,34 +4898,37 @@ class ConnectivityResponse final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ConnectivityResponse_class_data_; +// ------------------------------------------------------------------- -class ReplicateDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ReplicateDataRequest) */ { +class ReplicateDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ReplicateDataRequest) */ { public: inline ReplicateDataRequest() : ReplicateDataRequest(nullptr) {} - ~ReplicateDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR ReplicateDataRequest(::google::protobuf::internal::ConstantInitialized); + ~ReplicateDataRequest() PROTOBUF_FINAL; - inline ReplicateDataRequest(const ReplicateDataRequest& from) - : ReplicateDataRequest(nullptr, from) {} - ReplicateDataRequest(ReplicateDataRequest&& from) noexcept - : ReplicateDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ReplicateDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ReplicateDataRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ReplicateDataRequest(::google::protobuf::internal::ConstantInitialized); + inline ReplicateDataRequest(const ReplicateDataRequest& from) : ReplicateDataRequest(nullptr, from) {} + inline ReplicateDataRequest(ReplicateDataRequest&& from) noexcept + : ReplicateDataRequest(nullptr, ::std::move(from)) {} inline ReplicateDataRequest& operator=(const ReplicateDataRequest& from) { CopyFrom(from); return *this; } inline ReplicateDataRequest& operator=(ReplicateDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4817,47 +4940,35 @@ class ReplicateDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ReplicateDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ReplicateDataRequest* internal_default_instance() { - return reinterpret_cast( - &_ReplicateDataRequest_default_instance_); + return *reinterpret_cast( + &_ReplicateDataRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(ReplicateDataRequest& a, ReplicateDataRequest& b) { - a.Swap(&b); - } - inline void Swap(ReplicateDataRequest* other) { + static constexpr int kIndexInFileMessages = 4; + friend void swap(ReplicateDataRequest& a, ReplicateDataRequest& b) { a.Swap(&b); } + inline void Swap(ReplicateDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ReplicateDataRequest* other) { + void UnsafeArenaSwap(ReplicateDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4865,33 +4976,40 @@ class ReplicateDataRequest final : // implements Message ---------------------------------------------- - ReplicateDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ReplicateDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ReplicateDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ReplicateDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ReplicateDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ReplicateDataRequest"; } + + explicit ReplicateDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ReplicateDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ReplicateDataRequest& from); + ReplicateDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ReplicateDataRequest&& from) noexcept + : ReplicateDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ReplicateDataRequest(::google::protobuf::Arena* arena); - ReplicateDataRequest(::google::protobuf::Arena* arena, const ReplicateDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEntryFieldNumber = 1, }; @@ -4899,20 +5017,25 @@ class ReplicateDataRequest final : bool has_entry() const; void clear_entry() ; const ::dht::DataEntry& entry() const; - PROTOBUF_NODISCARD ::dht::DataEntry* release_entry(); - ::dht::DataEntry* mutable_entry(); - void set_allocated_entry(::dht::DataEntry* value); - void unsafe_arena_set_allocated_entry(::dht::DataEntry* value); - ::dht::DataEntry* unsafe_arena_release_entry(); + [[nodiscard]] ::dht::DataEntry* PROTOBUF_NULLABLE release_entry(); + ::dht::DataEntry* PROTOBUF_NONNULL mutable_entry(); + void set_allocated_entry(::dht::DataEntry* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_entry(::dht::DataEntry* PROTOBUF_NULLABLE value); + ::dht::DataEntry* PROTOBUF_NULLABLE unsafe_arena_release_entry(); private: const ::dht::DataEntry& _internal_entry() const; - ::dht::DataEntry* _internal_mutable_entry(); + ::dht::DataEntry* PROTOBUF_NONNULL _internal_mutable_entry(); public: // @@protoc_insertion_point(class_scope:dht.ReplicateDataRequest) 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; @@ -4921,48 +5044,52 @@ class ReplicateDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ReplicateDataRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::dht::DataEntry* entry_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::dht::DataEntry* PROTOBUF_NULLABLE entry_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class RecursiveOperationResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RecursiveOperationResponse) */ { +extern const ::google::protobuf::internal::ClassDataFull ReplicateDataRequest_class_data_; +// ------------------------------------------------------------------- + +class RecursiveOperationResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RecursiveOperationResponse) */ { public: inline RecursiveOperationResponse() : RecursiveOperationResponse(nullptr) {} - ~RecursiveOperationResponse() override; - template - explicit PROTOBUF_CONSTEXPR RecursiveOperationResponse(::google::protobuf::internal::ConstantInitialized); + ~RecursiveOperationResponse() PROTOBUF_FINAL; - inline RecursiveOperationResponse(const RecursiveOperationResponse& from) - : RecursiveOperationResponse(nullptr, from) {} - RecursiveOperationResponse(RecursiveOperationResponse&& from) noexcept - : RecursiveOperationResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RecursiveOperationResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RecursiveOperationResponse)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RecursiveOperationResponse(::google::protobuf::internal::ConstantInitialized); + + inline RecursiveOperationResponse(const RecursiveOperationResponse& from) : RecursiveOperationResponse(nullptr, from) {} + inline RecursiveOperationResponse(RecursiveOperationResponse&& from) noexcept + : RecursiveOperationResponse(nullptr, ::std::move(from)) {} inline RecursiveOperationResponse& operator=(const RecursiveOperationResponse& from) { CopyFrom(from); return *this; } inline RecursiveOperationResponse& operator=(RecursiveOperationResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4974,47 +5101,35 @@ class RecursiveOperationResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RecursiveOperationResponse& default_instance() { - return *internal_default_instance(); - } - static inline const RecursiveOperationResponse* internal_default_instance() { - return reinterpret_cast( - &_RecursiveOperationResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(RecursiveOperationResponse& a, RecursiveOperationResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RecursiveOperationResponse_default_instance_); } - inline void Swap(RecursiveOperationResponse* other) { + static constexpr int kIndexInFileMessages = 11; + friend void swap(RecursiveOperationResponse& a, RecursiveOperationResponse& b) { a.Swap(&b); } + inline void Swap(RecursiveOperationResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RecursiveOperationResponse* other) { + void UnsafeArenaSwap(RecursiveOperationResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5022,33 +5137,40 @@ class RecursiveOperationResponse final : // implements Message ---------------------------------------------- - RecursiveOperationResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RecursiveOperationResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RecursiveOperationResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RecursiveOperationResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RecursiveOperationResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RecursiveOperationResponse"; } + + explicit RecursiveOperationResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RecursiveOperationResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationResponse& from); + RecursiveOperationResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RecursiveOperationResponse&& from) noexcept + : RecursiveOperationResponse(arena) { + *this = ::std::move(from); } - protected: - explicit RecursiveOperationResponse(::google::protobuf::Arena* arena); - RecursiveOperationResponse(::google::protobuf::Arena* arena, const RecursiveOperationResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kClosestConnectedNodesFieldNumber = 1, kDataEntriesFieldNumber = 2, @@ -5062,17 +5184,16 @@ class RecursiveOperationResponse final : public: void clear_closestconnectednodes() ; - ::dht::PeerDescriptor* mutable_closestconnectednodes(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_closestconnectednodes(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_closestconnectednodes(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_closestconnectednodes(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_closestconnectednodes() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_closestconnectednodes(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_closestconnectednodes(); public: const ::dht::PeerDescriptor& closestconnectednodes(int index) const; - ::dht::PeerDescriptor* add_closestconnectednodes(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - closestconnectednodes() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_closestconnectednodes(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& closestconnectednodes() const; // repeated .dht.DataEntry dataEntries = 2; int dataentries_size() const; private: @@ -5080,17 +5201,16 @@ class RecursiveOperationResponse final : public: void clear_dataentries() ; - ::dht::DataEntry* mutable_dataentries(int index); - ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >* - mutable_dataentries(); + ::dht::DataEntry* PROTOBUF_NONNULL mutable_dataentries(int index); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL mutable_dataentries(); + private: const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& _internal_dataentries() const; - ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* _internal_mutable_dataentries(); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL _internal_mutable_dataentries(); public: const ::dht::DataEntry& dataentries(int index) const; - ::dht::DataEntry* add_dataentries(); - const ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >& - dataentries() const; + ::dht::DataEntry* PROTOBUF_NONNULL add_dataentries(); + const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& dataentries() const; // repeated .dht.PeerDescriptor routingPath = 4; int routingpath_size() const; private: @@ -5098,17 +5218,16 @@ class RecursiveOperationResponse final : public: void clear_routingpath() ; - ::dht::PeerDescriptor* mutable_routingpath(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_routingpath(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_routingpath(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_routingpath(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_routingpath() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_routingpath(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_routingpath(); public: const ::dht::PeerDescriptor& routingpath(int index) const; - ::dht::PeerDescriptor* add_routingpath(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - routingpath() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_routingpath(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& routingpath() const; // bool noCloserNodesFound = 3; void clear_noclosernodesfound() ; bool noclosernodesfound() const; @@ -5122,6 +5241,11 @@ class RecursiveOperationResponse final : // @@protoc_insertion_point(class_scope:dht.RecursiveOperationResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -5130,50 +5254,55 @@ class RecursiveOperationResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RecursiveOperationResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > closestconnectednodes_; ::google::protobuf::RepeatedPtrField< ::dht::DataEntry > dataentries_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > routingpath_; bool noclosernodesfound_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationResponse_class_data_; +// ------------------------------------------------------------------- -class HandshakeResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.HandshakeResponse) */ { +class HandshakeResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.HandshakeResponse) */ { public: inline HandshakeResponse() : HandshakeResponse(nullptr) {} - ~HandshakeResponse() override; - template - explicit PROTOBUF_CONSTEXPR HandshakeResponse(::google::protobuf::internal::ConstantInitialized); + ~HandshakeResponse() PROTOBUF_FINAL; - inline HandshakeResponse(const HandshakeResponse& from) - : HandshakeResponse(nullptr, from) {} - HandshakeResponse(HandshakeResponse&& from) noexcept - : HandshakeResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HandshakeResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HandshakeResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HandshakeResponse(::google::protobuf::internal::ConstantInitialized); + inline HandshakeResponse(const HandshakeResponse& from) : HandshakeResponse(nullptr, from) {} + inline HandshakeResponse(HandshakeResponse&& from) noexcept + : HandshakeResponse(nullptr, ::std::move(from)) {} inline HandshakeResponse& operator=(const HandshakeResponse& from) { CopyFrom(from); return *this; } inline HandshakeResponse& operator=(HandshakeResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5185,47 +5314,35 @@ class HandshakeResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HandshakeResponse& default_instance() { - return *internal_default_instance(); - } - static inline const HandshakeResponse* internal_default_instance() { - return reinterpret_cast( - &_HandshakeResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 22; - - friend void swap(HandshakeResponse& a, HandshakeResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_HandshakeResponse_default_instance_); } - inline void Swap(HandshakeResponse* other) { + static constexpr int kIndexInFileMessages = 22; + friend void swap(HandshakeResponse& a, HandshakeResponse& b) { a.Swap(&b); } + inline void Swap(HandshakeResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HandshakeResponse* other) { + void UnsafeArenaSwap(HandshakeResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5233,33 +5350,40 @@ class HandshakeResponse final : // implements Message ---------------------------------------------- - HandshakeResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HandshakeResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HandshakeResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.HandshakeResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HandshakeResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.HandshakeResponse"; } + + explicit HandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeResponse& from); + HandshakeResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HandshakeResponse&& from) noexcept + : HandshakeResponse(arena) { + *this = ::std::move(from); } - protected: - explicit HandshakeResponse(::google::protobuf::Arena* arena); - HandshakeResponse(::google::protobuf::Arena* arena, const HandshakeResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kVersionFieldNumber = 3, kSourcePeerDescriptorFieldNumber = 1, @@ -5267,33 +5391,32 @@ class HandshakeResponse final : }; // string version = 3; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.PeerDescriptor sourcePeerDescriptor = 1; bool has_sourcepeerdescriptor() const; void clear_sourcepeerdescriptor() ; const ::dht::PeerDescriptor& sourcepeerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcepeerdescriptor(); - ::dht::PeerDescriptor* mutable_sourcepeerdescriptor(); - void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcepeerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeerdescriptor(); + void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeerdescriptor(); private: const ::dht::PeerDescriptor& _internal_sourcepeerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeerdescriptor(); public: // optional .dht.HandshakeError error = 2; @@ -5310,6 +5433,11 @@ class HandshakeResponse final : // @@protoc_insertion_point(class_scope:dht.HandshakeResponse) 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; @@ -5318,50 +5446,54 @@ class HandshakeResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HandshakeResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::PeerDescriptor* sourcepeerdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcepeerdescriptor_; int error_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull HandshakeResponse_class_data_; +// ------------------------------------------------------------------- -class HandshakeRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.HandshakeRequest) */ { +class HandshakeRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.HandshakeRequest) */ { public: inline HandshakeRequest() : HandshakeRequest(nullptr) {} - ~HandshakeRequest() override; - template - explicit PROTOBUF_CONSTEXPR HandshakeRequest(::google::protobuf::internal::ConstantInitialized); + ~HandshakeRequest() PROTOBUF_FINAL; - inline HandshakeRequest(const HandshakeRequest& from) - : HandshakeRequest(nullptr, from) {} - HandshakeRequest(HandshakeRequest&& from) noexcept - : HandshakeRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HandshakeRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HandshakeRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HandshakeRequest(::google::protobuf::internal::ConstantInitialized); + inline HandshakeRequest(const HandshakeRequest& from) : HandshakeRequest(nullptr, from) {} + inline HandshakeRequest(HandshakeRequest&& from) noexcept + : HandshakeRequest(nullptr, ::std::move(from)) {} inline HandshakeRequest& operator=(const HandshakeRequest& from) { CopyFrom(from); return *this; } inline HandshakeRequest& operator=(HandshakeRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5373,47 +5505,35 @@ class HandshakeRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HandshakeRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_HandshakeRequest_default_instance_); } - static inline const HandshakeRequest* internal_default_instance() { - return reinterpret_cast( - &_HandshakeRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(HandshakeRequest& a, HandshakeRequest& b) { - a.Swap(&b); - } - inline void Swap(HandshakeRequest* other) { + static constexpr int kIndexInFileMessages = 21; + friend void swap(HandshakeRequest& a, HandshakeRequest& b) { a.Swap(&b); } + inline void Swap(HandshakeRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HandshakeRequest* other) { + void UnsafeArenaSwap(HandshakeRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5421,33 +5541,40 @@ class HandshakeRequest final : // implements Message ---------------------------------------------- - HandshakeRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HandshakeRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HandshakeRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.HandshakeRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HandshakeRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.HandshakeRequest"; } + + explicit HandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeRequest& from); + HandshakeRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HandshakeRequest&& from) noexcept + : HandshakeRequest(arena) { + *this = ::std::move(from); } - protected: - explicit HandshakeRequest(::google::protobuf::Arena* arena); - HandshakeRequest(::google::protobuf::Arena* arena, const HandshakeRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kVersionFieldNumber = 3, kSourcePeerDescriptorFieldNumber = 1, @@ -5455,53 +5582,57 @@ class HandshakeRequest final : }; // string version = 3; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.PeerDescriptor sourcePeerDescriptor = 1; bool has_sourcepeerdescriptor() const; void clear_sourcepeerdescriptor() ; const ::dht::PeerDescriptor& sourcepeerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcepeerdescriptor(); - ::dht::PeerDescriptor* mutable_sourcepeerdescriptor(); - void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcepeerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeerdescriptor(); + void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeerdescriptor(); private: const ::dht::PeerDescriptor& _internal_sourcepeerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeerdescriptor(); public: // optional .dht.PeerDescriptor targetPeerDescriptor = 2; bool has_targetpeerdescriptor() const; void clear_targetpeerdescriptor() ; const ::dht::PeerDescriptor& targetpeerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_targetpeerdescriptor(); - ::dht::PeerDescriptor* mutable_targetpeerdescriptor(); - void set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_targetpeerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_targetpeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_targetpeerdescriptor(); + void set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_targetpeerdescriptor(); private: const ::dht::PeerDescriptor& _internal_targetpeerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_targetpeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_targetpeerdescriptor(); public: // @@protoc_insertion_point(class_scope:dht.HandshakeRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 36, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -5510,50 +5641,54 @@ class HandshakeRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HandshakeRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::PeerDescriptor* sourcepeerdescriptor_; - ::dht::PeerDescriptor* targetpeerdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcepeerdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE targetpeerdescriptor_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull HandshakeRequest_class_data_; +// ------------------------------------------------------------------- -class ExternalStoreDataResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataResponse) */ { +class ExternalStoreDataResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataResponse) */ { public: inline ExternalStoreDataResponse() : ExternalStoreDataResponse(nullptr) {} - ~ExternalStoreDataResponse() override; - template - explicit PROTOBUF_CONSTEXPR ExternalStoreDataResponse(::google::protobuf::internal::ConstantInitialized); + ~ExternalStoreDataResponse() PROTOBUF_FINAL; - inline ExternalStoreDataResponse(const ExternalStoreDataResponse& from) - : ExternalStoreDataResponse(nullptr, from) {} - ExternalStoreDataResponse(ExternalStoreDataResponse&& from) noexcept - : ExternalStoreDataResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalStoreDataResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalStoreDataResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalStoreDataResponse(::google::protobuf::internal::ConstantInitialized); + inline ExternalStoreDataResponse(const ExternalStoreDataResponse& from) : ExternalStoreDataResponse(nullptr, from) {} + inline ExternalStoreDataResponse(ExternalStoreDataResponse&& from) noexcept + : ExternalStoreDataResponse(nullptr, ::std::move(from)) {} inline ExternalStoreDataResponse& operator=(const ExternalStoreDataResponse& from) { CopyFrom(from); return *this; } inline ExternalStoreDataResponse& operator=(ExternalStoreDataResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5565,47 +5700,35 @@ class ExternalStoreDataResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalStoreDataResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalStoreDataResponse* internal_default_instance() { - return reinterpret_cast( - &_ExternalStoreDataResponse_default_instance_); + return *reinterpret_cast( + &_ExternalStoreDataResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(ExternalStoreDataResponse& a, ExternalStoreDataResponse& b) { - a.Swap(&b); - } - inline void Swap(ExternalStoreDataResponse* other) { + static constexpr int kIndexInFileMessages = 3; + friend void swap(ExternalStoreDataResponse& a, ExternalStoreDataResponse& b) { a.Swap(&b); } + inline void Swap(ExternalStoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalStoreDataResponse* other) { + void UnsafeArenaSwap(ExternalStoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5613,33 +5736,40 @@ class ExternalStoreDataResponse final : // implements Message ---------------------------------------------- - ExternalStoreDataResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalStoreDataResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalStoreDataResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalStoreDataResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalStoreDataResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalStoreDataResponse"; } + + explicit ExternalStoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalStoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataResponse& from); + ExternalStoreDataResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalStoreDataResponse&& from) noexcept + : ExternalStoreDataResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalStoreDataResponse(::google::protobuf::Arena* arena); - ExternalStoreDataResponse(::google::protobuf::Arena* arena, const ExternalStoreDataResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kStorersFieldNumber = 1, }; @@ -5650,20 +5780,24 @@ class ExternalStoreDataResponse final : public: void clear_storers() ; - ::dht::PeerDescriptor* mutable_storers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_storers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_storers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_storers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_storers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_storers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_storers(); public: const ::dht::PeerDescriptor& storers(int index) const; - ::dht::PeerDescriptor* add_storers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - storers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_storers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& storers() const; // @@protoc_insertion_point(class_scope:dht.ExternalStoreDataResponse) 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; @@ -5672,47 +5806,52 @@ class ExternalStoreDataResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalStoreDataResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > storers_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataResponse_class_data_; +// ------------------------------------------------------------------- -class ExternalFetchDataResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataResponse) */ { +class ExternalFetchDataResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataResponse) */ { public: inline ExternalFetchDataResponse() : ExternalFetchDataResponse(nullptr) {} - ~ExternalFetchDataResponse() override; - template - explicit PROTOBUF_CONSTEXPR ExternalFetchDataResponse(::google::protobuf::internal::ConstantInitialized); + ~ExternalFetchDataResponse() PROTOBUF_FINAL; - inline ExternalFetchDataResponse(const ExternalFetchDataResponse& from) - : ExternalFetchDataResponse(nullptr, from) {} - ExternalFetchDataResponse(ExternalFetchDataResponse&& from) noexcept - : ExternalFetchDataResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalFetchDataResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalFetchDataResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalFetchDataResponse(::google::protobuf::internal::ConstantInitialized); + inline ExternalFetchDataResponse(const ExternalFetchDataResponse& from) : ExternalFetchDataResponse(nullptr, from) {} + inline ExternalFetchDataResponse(ExternalFetchDataResponse&& from) noexcept + : ExternalFetchDataResponse(nullptr, ::std::move(from)) {} inline ExternalFetchDataResponse& operator=(const ExternalFetchDataResponse& from) { CopyFrom(from); return *this; } inline ExternalFetchDataResponse& operator=(ExternalFetchDataResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5724,47 +5863,35 @@ class ExternalFetchDataResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalFetchDataResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ExternalFetchDataResponse_default_instance_); } - static inline const ExternalFetchDataResponse* internal_default_instance() { - return reinterpret_cast( - &_ExternalFetchDataResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 34; - - friend void swap(ExternalFetchDataResponse& a, ExternalFetchDataResponse& b) { - a.Swap(&b); - } - inline void Swap(ExternalFetchDataResponse* other) { + static constexpr int kIndexInFileMessages = 34; + friend void swap(ExternalFetchDataResponse& a, ExternalFetchDataResponse& b) { a.Swap(&b); } + inline void Swap(ExternalFetchDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalFetchDataResponse* other) { + void UnsafeArenaSwap(ExternalFetchDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5772,33 +5899,40 @@ class ExternalFetchDataResponse final : // implements Message ---------------------------------------------- - ExternalFetchDataResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalFetchDataResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalFetchDataResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalFetchDataResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalFetchDataResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalFetchDataResponse"; } + + explicit ExternalFetchDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalFetchDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataResponse& from); + ExternalFetchDataResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalFetchDataResponse&& from) noexcept + : ExternalFetchDataResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalFetchDataResponse(::google::protobuf::Arena* arena); - ExternalFetchDataResponse(::google::protobuf::Arena* arena, const ExternalFetchDataResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEntriesFieldNumber = 1, }; @@ -5809,20 +5943,24 @@ class ExternalFetchDataResponse final : public: void clear_entries() ; - ::dht::DataEntry* mutable_entries(int index); - ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >* - mutable_entries(); + ::dht::DataEntry* PROTOBUF_NONNULL mutable_entries(int index); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL mutable_entries(); + private: const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& _internal_entries() const; - ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* _internal_mutable_entries(); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL _internal_mutable_entries(); public: const ::dht::DataEntry& entries(int index) const; - ::dht::DataEntry* add_entries(); - const ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >& - entries() const; + ::dht::DataEntry* PROTOBUF_NONNULL add_entries(); + const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& entries() const; // @@protoc_insertion_point(class_scope:dht.ExternalFetchDataResponse) 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; @@ -5831,47 +5969,52 @@ class ExternalFetchDataResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalFetchDataResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::DataEntry > entries_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataResponse_class_data_; +// ------------------------------------------------------------------- -class ClosestRingPeersResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersResponse) */ { +class ClosestRingPeersResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersResponse) */ { public: inline ClosestRingPeersResponse() : ClosestRingPeersResponse(nullptr) {} - ~ClosestRingPeersResponse() override; - template - explicit PROTOBUF_CONSTEXPR ClosestRingPeersResponse(::google::protobuf::internal::ConstantInitialized); + ~ClosestRingPeersResponse() PROTOBUF_FINAL; - inline ClosestRingPeersResponse(const ClosestRingPeersResponse& from) - : ClosestRingPeersResponse(nullptr, from) {} - ClosestRingPeersResponse(ClosestRingPeersResponse&& from) noexcept - : ClosestRingPeersResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestRingPeersResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestRingPeersResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestRingPeersResponse(::google::protobuf::internal::ConstantInitialized); + inline ClosestRingPeersResponse(const ClosestRingPeersResponse& from) : ClosestRingPeersResponse(nullptr, from) {} + inline ClosestRingPeersResponse(ClosestRingPeersResponse&& from) noexcept + : ClosestRingPeersResponse(nullptr, ::std::move(from)) {} inline ClosestRingPeersResponse& operator=(const ClosestRingPeersResponse& from) { CopyFrom(from); return *this; } inline ClosestRingPeersResponse& operator=(ClosestRingPeersResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5883,47 +6026,35 @@ class ClosestRingPeersResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestRingPeersResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestRingPeersResponse* internal_default_instance() { - return reinterpret_cast( - &_ClosestRingPeersResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(ClosestRingPeersResponse& a, ClosestRingPeersResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ClosestRingPeersResponse_default_instance_); } - inline void Swap(ClosestRingPeersResponse* other) { + static constexpr int kIndexInFileMessages = 9; + friend void swap(ClosestRingPeersResponse& a, ClosestRingPeersResponse& b) { a.Swap(&b); } + inline void Swap(ClosestRingPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestRingPeersResponse* other) { + void UnsafeArenaSwap(ClosestRingPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5931,33 +6062,40 @@ class ClosestRingPeersResponse final : // implements Message ---------------------------------------------- - ClosestRingPeersResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestRingPeersResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestRingPeersResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestRingPeersResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestRingPeersResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestRingPeersResponse"; } + + explicit ClosestRingPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestRingPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersResponse& from); + ClosestRingPeersResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestRingPeersResponse&& from) noexcept + : ClosestRingPeersResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestRingPeersResponse(::google::protobuf::Arena* arena); - ClosestRingPeersResponse(::google::protobuf::Arena* arena, const ClosestRingPeersResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kLeftPeersFieldNumber = 1, kRightPeersFieldNumber = 2, @@ -5970,17 +6108,16 @@ class ClosestRingPeersResponse final : public: void clear_leftpeers() ; - ::dht::PeerDescriptor* mutable_leftpeers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_leftpeers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_leftpeers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_leftpeers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_leftpeers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_leftpeers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_leftpeers(); public: const ::dht::PeerDescriptor& leftpeers(int index) const; - ::dht::PeerDescriptor* add_leftpeers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - leftpeers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_leftpeers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& leftpeers() const; // repeated .dht.PeerDescriptor rightPeers = 2; int rightpeers_size() const; private: @@ -5988,36 +6125,39 @@ class ClosestRingPeersResponse final : public: void clear_rightpeers() ; - ::dht::PeerDescriptor* mutable_rightpeers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_rightpeers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_rightpeers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_rightpeers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_rightpeers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_rightpeers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_rightpeers(); public: const ::dht::PeerDescriptor& rightpeers(int index) const; - ::dht::PeerDescriptor* add_rightpeers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - rightpeers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_rightpeers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& rightpeers() const; // string requestId = 3; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestRingPeersResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 46, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6026,49 +6166,54 @@ class ClosestRingPeersResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestRingPeersResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > leftpeers_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > rightpeers_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersResponse_class_data_; +// ------------------------------------------------------------------- -class ClosestPeersResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestPeersResponse) */ { +class ClosestPeersResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestPeersResponse) */ { public: inline ClosestPeersResponse() : ClosestPeersResponse(nullptr) {} - ~ClosestPeersResponse() override; - template - explicit PROTOBUF_CONSTEXPR ClosestPeersResponse(::google::protobuf::internal::ConstantInitialized); + ~ClosestPeersResponse() PROTOBUF_FINAL; - inline ClosestPeersResponse(const ClosestPeersResponse& from) - : ClosestPeersResponse(nullptr, from) {} - ClosestPeersResponse(ClosestPeersResponse&& from) noexcept - : ClosestPeersResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestPeersResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestPeersResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestPeersResponse(::google::protobuf::internal::ConstantInitialized); + inline ClosestPeersResponse(const ClosestPeersResponse& from) : ClosestPeersResponse(nullptr, from) {} + inline ClosestPeersResponse(ClosestPeersResponse&& from) noexcept + : ClosestPeersResponse(nullptr, ::std::move(from)) {} inline ClosestPeersResponse& operator=(const ClosestPeersResponse& from) { CopyFrom(from); return *this; } inline ClosestPeersResponse& operator=(ClosestPeersResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -6080,47 +6225,35 @@ class ClosestPeersResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestPeersResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestPeersResponse* internal_default_instance() { - return reinterpret_cast( - &_ClosestPeersResponse_default_instance_); + return *reinterpret_cast( + &_ClosestPeersResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(ClosestPeersResponse& a, ClosestPeersResponse& b) { - a.Swap(&b); - } - inline void Swap(ClosestPeersResponse* other) { + static constexpr int kIndexInFileMessages = 7; + friend void swap(ClosestPeersResponse& a, ClosestPeersResponse& b) { a.Swap(&b); } + inline void Swap(ClosestPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestPeersResponse* other) { + void UnsafeArenaSwap(ClosestPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -6128,33 +6261,40 @@ class ClosestPeersResponse final : // implements Message ---------------------------------------------- - ClosestPeersResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestPeersResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestPeersResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestPeersResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestPeersResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestPeersResponse"; } + + explicit ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersResponse& from); + ClosestPeersResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestPeersResponse&& from) noexcept + : ClosestPeersResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestPeersResponse(::google::protobuf::Arena* arena); - ClosestPeersResponse(::google::protobuf::Arena* arena, const ClosestPeersResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kPeersFieldNumber = 1, kRequestIdFieldNumber = 2, @@ -6166,36 +6306,39 @@ class ClosestPeersResponse final : public: void clear_peers() ; - ::dht::PeerDescriptor* mutable_peers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_peers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_peers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_peers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_peers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_peers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_peers(); public: const ::dht::PeerDescriptor& peers(int index) const; - ::dht::PeerDescriptor* add_peers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - peers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_peers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& peers() const; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestPeersResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 42, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6204,48 +6347,53 @@ class ClosestPeersResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestPeersResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > peers_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_; +// ------------------------------------------------------------------- -class Message final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.Message) */ { +class Message final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.Message) */ { public: inline Message() : Message(nullptr) {} - ~Message() override; - template - explicit PROTOBUF_CONSTEXPR Message(::google::protobuf::internal::ConstantInitialized); + ~Message() PROTOBUF_FINAL; - inline Message(const Message& from) - : Message(nullptr, from) {} - Message(Message&& from) noexcept - : Message() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Message* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Message)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR Message(::google::protobuf::internal::ConstantInitialized); + inline Message(const Message& from) : Message(nullptr, from) {} + inline Message(Message&& from) noexcept + : Message(nullptr, ::std::move(from)) {} inline Message& operator=(const Message& from) { CopyFrom(from); return *this; } inline Message& operator=(Message&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -6257,22 +6405,23 @@ class Message final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const Message& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_Message_default_instance_); } enum BodyCase { kRpcMessage = 5, @@ -6283,31 +6432,17 @@ class Message final : kRecursiveOperationRequest = 10, BODY_NOT_SET = 0, }; - - static inline const Message* internal_default_instance() { - return reinterpret_cast( - &_Message_default_instance_); - } - static constexpr int kIndexInFileMessages = - 23; - - friend void swap(Message& a, Message& b) { - a.Swap(&b); - } - inline void Swap(Message* other) { + static constexpr int kIndexInFileMessages = 23; + friend void swap(Message& a, Message& b) { a.Swap(&b); } + inline void Swap(Message* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Message* other) { + void UnsafeArenaSwap(Message* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -6315,33 +6450,40 @@ class Message final : // implements Message ---------------------------------------------- - Message* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + Message* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(Message* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.Message"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Message* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.Message"; } + + explicit Message(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + Message(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Message& from); + Message( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Message&& from) noexcept + : Message(arena) { + *this = ::std::move(from); } - protected: - explicit Message(::google::protobuf::Arena* arena); - Message(::google::protobuf::Arena* arena, const Message& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kMessageIdFieldNumber = 1, kServiceIdFieldNumber = 4, @@ -6356,64 +6498,62 @@ class Message final : }; // string messageId = 1; void clear_messageid() ; - const std::string& messageid() const; - template + const ::std::string& messageid() const; + template void set_messageid(Arg_&& arg, Args_... args); - std::string* mutable_messageid(); - PROTOBUF_NODISCARD std::string* release_messageid(); - void set_allocated_messageid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_messageid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_messageid(); + void set_allocated_messageid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_messageid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messageid( - const std::string& value); - std::string* _internal_mutable_messageid(); + const ::std::string& _internal_messageid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_messageid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_messageid(); public: // string serviceId = 4; void clear_serviceid() ; - const std::string& serviceid() const; - template + const ::std::string& serviceid() const; + template void set_serviceid(Arg_&& arg, Args_... args); - std::string* mutable_serviceid(); - PROTOBUF_NODISCARD std::string* release_serviceid(); - void set_allocated_serviceid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_serviceid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_serviceid(); + void set_allocated_serviceid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_serviceid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_serviceid( - const std::string& value); - std::string* _internal_mutable_serviceid(); + const ::std::string& _internal_serviceid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_serviceid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_serviceid(); public: // .dht.PeerDescriptor sourceDescriptor = 2; bool has_sourcedescriptor() const; void clear_sourcedescriptor() ; const ::dht::PeerDescriptor& sourcedescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcedescriptor(); - ::dht::PeerDescriptor* mutable_sourcedescriptor(); - void set_allocated_sourcedescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcedescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcedescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcedescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcedescriptor(); + void set_allocated_sourcedescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcedescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcedescriptor(); private: const ::dht::PeerDescriptor& _internal_sourcedescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_sourcedescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcedescriptor(); public: // .dht.PeerDescriptor targetDescriptor = 3; bool has_targetdescriptor() const; void clear_targetdescriptor() ; const ::dht::PeerDescriptor& targetdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_targetdescriptor(); - ::dht::PeerDescriptor* mutable_targetdescriptor(); - void set_allocated_targetdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_targetdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_targetdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_targetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_targetdescriptor(); + void set_allocated_targetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_targetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_targetdescriptor(); private: const ::dht::PeerDescriptor& _internal_targetdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_targetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_targetdescriptor(); public: // .protorpc.RpcMessage rpcMessage = 5; @@ -6424,15 +6564,15 @@ class Message final : public: void clear_rpcmessage() ; const ::protorpc::RpcMessage& rpcmessage() const; - PROTOBUF_NODISCARD ::protorpc::RpcMessage* release_rpcmessage(); - ::protorpc::RpcMessage* mutable_rpcmessage(); - void set_allocated_rpcmessage(::protorpc::RpcMessage* value); - void unsafe_arena_set_allocated_rpcmessage(::protorpc::RpcMessage* value); - ::protorpc::RpcMessage* unsafe_arena_release_rpcmessage(); + [[nodiscard]] ::protorpc::RpcMessage* PROTOBUF_NULLABLE release_rpcmessage(); + ::protorpc::RpcMessage* PROTOBUF_NONNULL mutable_rpcmessage(); + void set_allocated_rpcmessage(::protorpc::RpcMessage* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_rpcmessage(::protorpc::RpcMessage* PROTOBUF_NULLABLE value); + ::protorpc::RpcMessage* PROTOBUF_NULLABLE unsafe_arena_release_rpcmessage(); private: const ::protorpc::RpcMessage& _internal_rpcmessage() const; - ::protorpc::RpcMessage* _internal_mutable_rpcmessage(); + ::protorpc::RpcMessage* PROTOBUF_NONNULL _internal_mutable_rpcmessage(); public: // .dht.ConnectivityRequest connectivityRequest = 6; @@ -6443,15 +6583,15 @@ class Message final : public: void clear_connectivityrequest() ; const ::dht::ConnectivityRequest& connectivityrequest() const; - PROTOBUF_NODISCARD ::dht::ConnectivityRequest* release_connectivityrequest(); - ::dht::ConnectivityRequest* mutable_connectivityrequest(); - void set_allocated_connectivityrequest(::dht::ConnectivityRequest* value); - void unsafe_arena_set_allocated_connectivityrequest(::dht::ConnectivityRequest* value); - ::dht::ConnectivityRequest* unsafe_arena_release_connectivityrequest(); + [[nodiscard]] ::dht::ConnectivityRequest* PROTOBUF_NULLABLE release_connectivityrequest(); + ::dht::ConnectivityRequest* PROTOBUF_NONNULL mutable_connectivityrequest(); + void set_allocated_connectivityrequest(::dht::ConnectivityRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_connectivityrequest(::dht::ConnectivityRequest* PROTOBUF_NULLABLE value); + ::dht::ConnectivityRequest* PROTOBUF_NULLABLE unsafe_arena_release_connectivityrequest(); private: const ::dht::ConnectivityRequest& _internal_connectivityrequest() const; - ::dht::ConnectivityRequest* _internal_mutable_connectivityrequest(); + ::dht::ConnectivityRequest* PROTOBUF_NONNULL _internal_mutable_connectivityrequest(); public: // .dht.ConnectivityResponse connectivityResponse = 7; @@ -6462,15 +6602,15 @@ class Message final : public: void clear_connectivityresponse() ; const ::dht::ConnectivityResponse& connectivityresponse() const; - PROTOBUF_NODISCARD ::dht::ConnectivityResponse* release_connectivityresponse(); - ::dht::ConnectivityResponse* mutable_connectivityresponse(); - void set_allocated_connectivityresponse(::dht::ConnectivityResponse* value); - void unsafe_arena_set_allocated_connectivityresponse(::dht::ConnectivityResponse* value); - ::dht::ConnectivityResponse* unsafe_arena_release_connectivityresponse(); + [[nodiscard]] ::dht::ConnectivityResponse* PROTOBUF_NULLABLE release_connectivityresponse(); + ::dht::ConnectivityResponse* PROTOBUF_NONNULL mutable_connectivityresponse(); + void set_allocated_connectivityresponse(::dht::ConnectivityResponse* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_connectivityresponse(::dht::ConnectivityResponse* PROTOBUF_NULLABLE value); + ::dht::ConnectivityResponse* PROTOBUF_NULLABLE unsafe_arena_release_connectivityresponse(); private: const ::dht::ConnectivityResponse& _internal_connectivityresponse() const; - ::dht::ConnectivityResponse* _internal_mutable_connectivityresponse(); + ::dht::ConnectivityResponse* PROTOBUF_NONNULL _internal_mutable_connectivityresponse(); public: // .dht.HandshakeRequest handshakeRequest = 8; @@ -6481,15 +6621,15 @@ class Message final : public: void clear_handshakerequest() ; const ::dht::HandshakeRequest& handshakerequest() const; - PROTOBUF_NODISCARD ::dht::HandshakeRequest* release_handshakerequest(); - ::dht::HandshakeRequest* mutable_handshakerequest(); - void set_allocated_handshakerequest(::dht::HandshakeRequest* value); - void unsafe_arena_set_allocated_handshakerequest(::dht::HandshakeRequest* value); - ::dht::HandshakeRequest* unsafe_arena_release_handshakerequest(); + [[nodiscard]] ::dht::HandshakeRequest* PROTOBUF_NULLABLE release_handshakerequest(); + ::dht::HandshakeRequest* PROTOBUF_NONNULL mutable_handshakerequest(); + void set_allocated_handshakerequest(::dht::HandshakeRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_handshakerequest(::dht::HandshakeRequest* PROTOBUF_NULLABLE value); + ::dht::HandshakeRequest* PROTOBUF_NULLABLE unsafe_arena_release_handshakerequest(); private: const ::dht::HandshakeRequest& _internal_handshakerequest() const; - ::dht::HandshakeRequest* _internal_mutable_handshakerequest(); + ::dht::HandshakeRequest* PROTOBUF_NONNULL _internal_mutable_handshakerequest(); public: // .dht.HandshakeResponse handshakeResponse = 9; @@ -6500,15 +6640,15 @@ class Message final : public: void clear_handshakeresponse() ; const ::dht::HandshakeResponse& handshakeresponse() const; - PROTOBUF_NODISCARD ::dht::HandshakeResponse* release_handshakeresponse(); - ::dht::HandshakeResponse* mutable_handshakeresponse(); - void set_allocated_handshakeresponse(::dht::HandshakeResponse* value); - void unsafe_arena_set_allocated_handshakeresponse(::dht::HandshakeResponse* value); - ::dht::HandshakeResponse* unsafe_arena_release_handshakeresponse(); + [[nodiscard]] ::dht::HandshakeResponse* PROTOBUF_NULLABLE release_handshakeresponse(); + ::dht::HandshakeResponse* PROTOBUF_NONNULL mutable_handshakeresponse(); + void set_allocated_handshakeresponse(::dht::HandshakeResponse* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_handshakeresponse(::dht::HandshakeResponse* PROTOBUF_NULLABLE value); + ::dht::HandshakeResponse* PROTOBUF_NULLABLE unsafe_arena_release_handshakeresponse(); private: const ::dht::HandshakeResponse& _internal_handshakeresponse() const; - ::dht::HandshakeResponse* _internal_mutable_handshakeresponse(); + ::dht::HandshakeResponse* PROTOBUF_NONNULL _internal_mutable_handshakeresponse(); public: // .dht.RecursiveOperationRequest recursiveOperationRequest = 10; @@ -6519,15 +6659,15 @@ class Message final : public: void clear_recursiveoperationrequest() ; const ::dht::RecursiveOperationRequest& recursiveoperationrequest() const; - PROTOBUF_NODISCARD ::dht::RecursiveOperationRequest* release_recursiveoperationrequest(); - ::dht::RecursiveOperationRequest* mutable_recursiveoperationrequest(); - void set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* value); - void unsafe_arena_set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* value); - ::dht::RecursiveOperationRequest* unsafe_arena_release_recursiveoperationrequest(); + [[nodiscard]] ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE release_recursiveoperationrequest(); + ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL mutable_recursiveoperationrequest(); + void set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE value); + ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE unsafe_arena_release_recursiveoperationrequest(); private: const ::dht::RecursiveOperationRequest& _internal_recursiveoperationrequest() const; - ::dht::RecursiveOperationRequest* _internal_mutable_recursiveoperationrequest(); + ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL _internal_mutable_recursiveoperationrequest(); public: void clear_body(); @@ -6541,9 +6681,13 @@ class Message final : void set_has_handshakerequest(); void set_has_handshakeresponse(); void set_has_recursiveoperationrequest(); - inline bool has_body() const; inline void clear_has_body(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 10, + 8, 46, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6552,63 +6696,66 @@ class Message final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const Message& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr messageid_; ::google::protobuf::internal::ArenaStringPtr serviceid_; - ::dht::PeerDescriptor* sourcedescriptor_; - ::dht::PeerDescriptor* targetdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcedescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE targetdescriptor_; union BodyUnion { constexpr BodyUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::protorpc::RpcMessage* rpcmessage_; - ::dht::ConnectivityRequest* connectivityrequest_; - ::dht::ConnectivityResponse* connectivityresponse_; - ::dht::HandshakeRequest* handshakerequest_; - ::dht::HandshakeResponse* handshakeresponse_; - ::dht::RecursiveOperationRequest* recursiveoperationrequest_; + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE rpcmessage_; + ::google::protobuf::Message* PROTOBUF_NULLABLE connectivityrequest_; + ::google::protobuf::Message* PROTOBUF_NULLABLE connectivityresponse_; + ::google::protobuf::Message* PROTOBUF_NULLABLE handshakerequest_; + ::google::protobuf::Message* PROTOBUF_NULLABLE handshakeresponse_; + ::google::protobuf::Message* PROTOBUF_NULLABLE recursiveoperationrequest_; } body_; ::uint32_t _oneof_case_[1]; - PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class RouteMessageWrapper final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RouteMessageWrapper) */ { +extern const ::google::protobuf::internal::ClassDataFull Message_class_data_; +// ------------------------------------------------------------------- + +class RouteMessageWrapper final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RouteMessageWrapper) */ { public: inline RouteMessageWrapper() : RouteMessageWrapper(nullptr) {} - ~RouteMessageWrapper() override; - template - explicit PROTOBUF_CONSTEXPR RouteMessageWrapper(::google::protobuf::internal::ConstantInitialized); + ~RouteMessageWrapper() PROTOBUF_FINAL; - inline RouteMessageWrapper(const RouteMessageWrapper& from) - : RouteMessageWrapper(nullptr, from) {} - RouteMessageWrapper(RouteMessageWrapper&& from) noexcept - : RouteMessageWrapper() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RouteMessageWrapper* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RouteMessageWrapper)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RouteMessageWrapper(::google::protobuf::internal::ConstantInitialized); + + inline RouteMessageWrapper(const RouteMessageWrapper& from) : RouteMessageWrapper(nullptr, from) {} + inline RouteMessageWrapper(RouteMessageWrapper&& from) noexcept + : RouteMessageWrapper(nullptr, ::std::move(from)) {} inline RouteMessageWrapper& operator=(const RouteMessageWrapper& from) { CopyFrom(from); return *this; } inline RouteMessageWrapper& operator=(RouteMessageWrapper&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -6620,47 +6767,35 @@ class RouteMessageWrapper final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RouteMessageWrapper& default_instance() { - return *internal_default_instance(); - } - static inline const RouteMessageWrapper* internal_default_instance() { - return reinterpret_cast( - &_RouteMessageWrapper_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(RouteMessageWrapper& a, RouteMessageWrapper& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RouteMessageWrapper_default_instance_); } - inline void Swap(RouteMessageWrapper* other) { + static constexpr int kIndexInFileMessages = 17; + friend void swap(RouteMessageWrapper& a, RouteMessageWrapper& b) { a.Swap(&b); } + inline void Swap(RouteMessageWrapper* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RouteMessageWrapper* other) { + void UnsafeArenaSwap(RouteMessageWrapper* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -6668,33 +6803,40 @@ class RouteMessageWrapper final : // implements Message ---------------------------------------------- - RouteMessageWrapper* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RouteMessageWrapper* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RouteMessageWrapper* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RouteMessageWrapper"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RouteMessageWrapper* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RouteMessageWrapper"; } + + explicit RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageWrapper& from); + RouteMessageWrapper( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RouteMessageWrapper&& from) noexcept + : RouteMessageWrapper(arena) { + *this = ::std::move(from); } - protected: - explicit RouteMessageWrapper(::google::protobuf::Arena* arena); - RouteMessageWrapper(::google::protobuf::Arena* arena, const RouteMessageWrapper& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kReachableThroughFieldNumber = 5, kRoutingPathFieldNumber = 6, @@ -6711,17 +6853,16 @@ class RouteMessageWrapper final : public: void clear_reachablethrough() ; - ::dht::PeerDescriptor* mutable_reachablethrough(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_reachablethrough(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_reachablethrough(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_reachablethrough(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_reachablethrough() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_reachablethrough(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_reachablethrough(); public: const ::dht::PeerDescriptor& reachablethrough(int index) const; - ::dht::PeerDescriptor* add_reachablethrough(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - reachablethrough() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_reachablethrough(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& reachablethrough() const; // repeated .dht.PeerDescriptor routingPath = 6; int routingpath_size() const; private: @@ -6729,17 +6870,16 @@ class RouteMessageWrapper final : public: void clear_routingpath() ; - ::dht::PeerDescriptor* mutable_routingpath(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_routingpath(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_routingpath(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_routingpath(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_routingpath() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_routingpath(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_routingpath(); public: const ::dht::PeerDescriptor& routingpath(int index) const; - ::dht::PeerDescriptor* add_routingpath(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - routingpath() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_routingpath(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& routingpath() const; // repeated string parallelRootNodeIds = 7; int parallelrootnodeids_size() const; private: @@ -6747,92 +6887,89 @@ class RouteMessageWrapper final : public: void clear_parallelrootnodeids() ; - const std::string& parallelrootnodeids(int index) const; - std::string* mutable_parallelrootnodeids(int index); - void set_parallelrootnodeids(int index, const std::string& value); - void set_parallelrootnodeids(int index, std::string&& value); - void set_parallelrootnodeids(int index, const char* value); - void set_parallelrootnodeids(int index, const char* value, std::size_t size); - void set_parallelrootnodeids(int index, absl::string_view value); - std::string* add_parallelrootnodeids(); - void add_parallelrootnodeids(const std::string& value); - void add_parallelrootnodeids(std::string&& value); - void add_parallelrootnodeids(const char* value); - void add_parallelrootnodeids(const char* value, std::size_t size); - void add_parallelrootnodeids(absl::string_view value); - const ::google::protobuf::RepeatedPtrField& parallelrootnodeids() const; - ::google::protobuf::RepeatedPtrField* mutable_parallelrootnodeids(); - - private: - const ::google::protobuf::RepeatedPtrField& _internal_parallelrootnodeids() const; - ::google::protobuf::RepeatedPtrField* _internal_mutable_parallelrootnodeids(); + const ::std::string& parallelrootnodeids(int index) const; + ::std::string* PROTOBUF_NONNULL mutable_parallelrootnodeids(int index); + template + void set_parallelrootnodeids(int index, Arg_&& value, Args_... args); + ::std::string* PROTOBUF_NONNULL add_parallelrootnodeids(); + template + void add_parallelrootnodeids(Arg_&& value, Args_... args); + const ::google::protobuf::RepeatedPtrField<::std::string>& parallelrootnodeids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_parallelrootnodeids(); + + private: + const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_parallelrootnodeids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_parallelrootnodeids(); public: // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // bytes target = 3; void clear_target() ; - const std::string& target() const; - template + const ::std::string& target() const; + template void set_target(Arg_&& arg, Args_... args); - std::string* mutable_target(); - PROTOBUF_NODISCARD std::string* release_target(); - void set_allocated_target(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_target(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_target(); + void set_allocated_target(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_target() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_target( - const std::string& value); - std::string* _internal_mutable_target(); + const ::std::string& _internal_target() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_target(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_target(); public: // .dht.PeerDescriptor sourcePeer = 2; bool has_sourcepeer() const; void clear_sourcepeer() ; const ::dht::PeerDescriptor& sourcepeer() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcepeer(); - ::dht::PeerDescriptor* mutable_sourcepeer(); - void set_allocated_sourcepeer(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeer(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcepeer(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeer(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeer(); + void set_allocated_sourcepeer(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeer(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeer(); private: const ::dht::PeerDescriptor& _internal_sourcepeer() const; - ::dht::PeerDescriptor* _internal_mutable_sourcepeer(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeer(); public: // .dht.Message message = 4; bool has_message() const; void clear_message() ; const ::dht::Message& message() const; - PROTOBUF_NODISCARD ::dht::Message* release_message(); - ::dht::Message* mutable_message(); - void set_allocated_message(::dht::Message* value); - void unsafe_arena_set_allocated_message(::dht::Message* value); - ::dht::Message* unsafe_arena_release_message(); + [[nodiscard]] ::dht::Message* PROTOBUF_NULLABLE release_message(); + ::dht::Message* PROTOBUF_NONNULL mutable_message(); + void set_allocated_message(::dht::Message* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_message(::dht::Message* PROTOBUF_NULLABLE value); + ::dht::Message* PROTOBUF_NULLABLE unsafe_arena_release_message(); private: const ::dht::Message& _internal_message() const; - ::dht::Message* _internal_mutable_message(); + ::dht::Message* PROTOBUF_NONNULL _internal_mutable_message(); public: // @@protoc_insertion_point(class_scope:dht.RouteMessageWrapper) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 4, 60, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6841,28 +6978,31 @@ class RouteMessageWrapper final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RouteMessageWrapper& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > reachablethrough_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > routingpath_; - ::google::protobuf::RepeatedPtrField parallelrootnodeids_; + ::google::protobuf::RepeatedPtrField<::std::string> parallelrootnodeids_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr target_; - ::dht::PeerDescriptor* sourcepeer_; - ::dht::Message* message_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcepeer_; + ::dht::Message* PROTOBUF_NULLABLE message_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_; + // =================================================================== @@ -6881,65 +7021,77 @@ class RouteMessageWrapper final : // bytes key = 1; inline void StoreDataRequest::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& StoreDataRequest::key() const +inline const ::std::string& StoreDataRequest::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.StoreDataRequest.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.StoreDataRequest.key) } -inline std::string* StoreDataRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.key) return _s; } -inline const std::string& StoreDataRequest::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StoreDataRequest::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void StoreDataRequest::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StoreDataRequest::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* StoreDataRequest::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* StoreDataRequest::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StoreDataRequest::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void StoreDataRequest::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.StoreDataRequest.key) } // .google.protobuf.Any data = 2; inline bool StoreDataRequest::has_data() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline const ::google::protobuf::Any& StoreDataRequest::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -6947,76 +7099,78 @@ inline const ::google::protobuf::Any& StoreDataRequest::data() const ABSL_ATTRIB // @@protoc_insertion_point(field_get:dht.StoreDataRequest.data) return _internal_data(); } -inline void StoreDataRequest::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::unsafe_arena_set_allocated_data( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.StoreDataRequest.data) } -inline ::google::protobuf::Any* StoreDataRequest::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE StoreDataRequest::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* released = _impl_.data_; _impl_.data_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* StoreDataRequest::unsafe_arena_release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE StoreDataRequest::unsafe_arena_release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.data) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } -inline ::google::protobuf::Any* StoreDataRequest::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.data_; } -inline ::google::protobuf::Any* StoreDataRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL StoreDataRequest::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.data) return _msg; } -inline void StoreDataRequest::set_allocated_data(::google::protobuf::Any* value) { +inline void StoreDataRequest::set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -7025,65 +7179,77 @@ inline void StoreDataRequest::set_allocated_data(::google::protobuf::Any* value) // bytes creator = 3; inline void StoreDataRequest::clear_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& StoreDataRequest::creator() const +inline const ::std::string& StoreDataRequest::creator() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.StoreDataRequest.creator) return _internal_creator(); } template -inline PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_creator(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_creator(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.creator_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.StoreDataRequest.creator) } -inline std::string* StoreDataRequest::mutable_creator() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_creator(); +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::mutable_creator() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_creator(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.creator) return _s; } -inline const std::string& StoreDataRequest::_internal_creator() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StoreDataRequest::_internal_creator() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.creator_.Get(); } -inline void StoreDataRequest::_internal_set_creator(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StoreDataRequest::_internal_set_creator(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.Set(value, GetArena()); } -inline std::string* StoreDataRequest::_internal_mutable_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.creator_.Mutable( GetArena()); } -inline std::string* StoreDataRequest::release_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StoreDataRequest::release_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.creator) - return _impl_.creator_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.creator_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.creator_.Set("", GetArena()); + } + return released; } -inline void StoreDataRequest::set_allocated_creator(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::set_allocated_creator(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.creator_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.creator_.IsDefault()) { - _impl_.creator_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.creator_.IsDefault()) { + _impl_.creator_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.StoreDataRequest.creator) } // .google.protobuf.Timestamp createdAt = 4; inline bool StoreDataRequest::has_createdat() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.createdat_ != nullptr); return value; } inline const ::google::protobuf::Timestamp& StoreDataRequest::_internal_createdat() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Timestamp* p = _impl_.createdat_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Timestamp_default_instance_); } @@ -7091,76 +7257,78 @@ inline const ::google::protobuf::Timestamp& StoreDataRequest::createdat() const // @@protoc_insertion_point(field_get:dht.StoreDataRequest.createdAt) return _internal_createdat(); } -inline void StoreDataRequest::unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::unsafe_arena_set_allocated_createdat( + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.StoreDataRequest.createdAt) } -inline ::google::protobuf::Timestamp* StoreDataRequest::release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE StoreDataRequest::release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* released = _impl_.createdat_; _impl_.createdat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Timestamp* StoreDataRequest::unsafe_arena_release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE StoreDataRequest::unsafe_arena_release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.createdAt) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* temp = _impl_.createdat_; _impl_.createdat_ = nullptr; return temp; } -inline ::google::protobuf::Timestamp* StoreDataRequest::_internal_mutable_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena()); _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(p); } return _impl_.createdat_; } -inline ::google::protobuf::Timestamp* StoreDataRequest::mutable_createdat() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL StoreDataRequest::mutable_createdat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* _msg = _internal_mutable_createdat(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.createdAt) return _msg; } -inline void StoreDataRequest::set_allocated_createdat(::google::protobuf::Timestamp* value) { +inline void StoreDataRequest::set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); @@ -7169,8 +7337,10 @@ inline void StoreDataRequest::set_allocated_createdat(::google::protobuf::Timest // uint32 ttl = 5; inline void StoreDataRequest::clear_ttl() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline ::uint32_t StoreDataRequest::ttl() const { // @@protoc_insertion_point(field_get:dht.StoreDataRequest.ttl) @@ -7178,15 +7348,15 @@ inline ::uint32_t StoreDataRequest::ttl() const { } inline void StoreDataRequest::set_ttl(::uint32_t value) { _internal_set_ttl(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:dht.StoreDataRequest.ttl) } inline ::uint32_t StoreDataRequest::_internal_ttl() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ttl_; } inline void StoreDataRequest::_internal_set_ttl(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = value; } @@ -7200,65 +7370,77 @@ inline void StoreDataRequest::_internal_set_ttl(::uint32_t value) { // bytes key = 1; inline void ExternalStoreDataRequest::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ExternalStoreDataRequest::key() const +inline const ::std::string& ExternalStoreDataRequest::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ExternalStoreDataRequest.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void ExternalStoreDataRequest::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ExternalStoreDataRequest::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ExternalStoreDataRequest.key) } -inline std::string* ExternalStoreDataRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL ExternalStoreDataRequest::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.ExternalStoreDataRequest.key) return _s; } -inline const std::string& ExternalStoreDataRequest::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ExternalStoreDataRequest::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void ExternalStoreDataRequest::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ExternalStoreDataRequest::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* ExternalStoreDataRequest::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ExternalStoreDataRequest::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* ExternalStoreDataRequest::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ExternalStoreDataRequest::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ExternalStoreDataRequest.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void ExternalStoreDataRequest::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ExternalStoreDataRequest::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ExternalStoreDataRequest.key) } // .google.protobuf.Any data = 2; inline bool ExternalStoreDataRequest::has_data() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline const ::google::protobuf::Any& ExternalStoreDataRequest::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -7266,76 +7448,78 @@ inline const ::google::protobuf::Any& ExternalStoreDataRequest::data() const ABS // @@protoc_insertion_point(field_get:dht.ExternalStoreDataRequest.data) return _internal_data(); } -inline void ExternalStoreDataRequest::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ExternalStoreDataRequest::unsafe_arena_set_allocated_data( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.ExternalStoreDataRequest.data) } -inline ::google::protobuf::Any* ExternalStoreDataRequest::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE ExternalStoreDataRequest::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::google::protobuf::Any* released = _impl_.data_; _impl_.data_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* ExternalStoreDataRequest::unsafe_arena_release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE ExternalStoreDataRequest::unsafe_arena_release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ExternalStoreDataRequest.data) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::google::protobuf::Any* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } -inline ::google::protobuf::Any* ExternalStoreDataRequest::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL ExternalStoreDataRequest::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.data_; } -inline ::google::protobuf::Any* ExternalStoreDataRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL ExternalStoreDataRequest::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::google::protobuf::Any* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:dht.ExternalStoreDataRequest.data) return _msg; } -inline void ExternalStoreDataRequest::set_allocated_data(::google::protobuf::Any* value) { +inline void ExternalStoreDataRequest::set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -7354,18 +7538,21 @@ inline int ExternalStoreDataResponse::storers_size() const { return _internal_storers_size(); } inline void ExternalStoreDataResponse::clear_storers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.storers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* ExternalStoreDataResponse::mutable_storers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ExternalStoreDataResponse::mutable_storers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ExternalStoreDataResponse.storers) return _internal_mutable_storers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ExternalStoreDataResponse::mutable_storers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ExternalStoreDataResponse::mutable_storers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ExternalStoreDataResponse.storers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_storers(); } inline const ::dht::PeerDescriptor& ExternalStoreDataResponse::storers(int index) const @@ -7373,9 +7560,13 @@ inline const ::dht::PeerDescriptor& ExternalStoreDataResponse::storers(int index // @@protoc_insertion_point(field_get:dht.ExternalStoreDataResponse.storers) return _internal_storers().Get(index); } -inline ::dht::PeerDescriptor* ExternalStoreDataResponse::add_storers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_storers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ExternalStoreDataResponse::add_storers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_storers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ExternalStoreDataResponse.storers) return _add; } @@ -7386,12 +7577,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Extern } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ExternalStoreDataResponse::_internal_storers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.storers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ExternalStoreDataResponse::_internal_mutable_storers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.storers_; } @@ -7401,17 +7592,18 @@ ExternalStoreDataResponse::_internal_mutable_storers() { // .dht.DataEntry entry = 1; inline bool ReplicateDataRequest::has_entry() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); PROTOBUF_ASSUME(!value || _impl_.entry_ != nullptr); return value; } inline void ReplicateDataRequest::clear_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.entry_ != nullptr) _impl_.entry_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline const ::dht::DataEntry& ReplicateDataRequest::_internal_entry() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::DataEntry* p = _impl_.entry_; return p != nullptr ? *p : reinterpret_cast(::dht::_DataEntry_default_instance_); } @@ -7419,76 +7611,78 @@ inline const ::dht::DataEntry& ReplicateDataRequest::entry() const ABSL_ATTRIBUT // @@protoc_insertion_point(field_get:dht.ReplicateDataRequest.entry) return _internal_entry(); } -inline void ReplicateDataRequest::unsafe_arena_set_allocated_entry(::dht::DataEntry* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ReplicateDataRequest::unsafe_arena_set_allocated_entry( + ::dht::DataEntry* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entry_); } _impl_.entry_ = reinterpret_cast<::dht::DataEntry*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.ReplicateDataRequest.entry) } -inline ::dht::DataEntry* ReplicateDataRequest::release_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::DataEntry* PROTOBUF_NULLABLE ReplicateDataRequest::release_entry() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::DataEntry* released = _impl_.entry_; _impl_.entry_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::DataEntry* ReplicateDataRequest::unsafe_arena_release_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::DataEntry* PROTOBUF_NULLABLE ReplicateDataRequest::unsafe_arena_release_entry() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ReplicateDataRequest.entry) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::DataEntry* temp = _impl_.entry_; _impl_.entry_ = nullptr; return temp; } -inline ::dht::DataEntry* ReplicateDataRequest::_internal_mutable_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::DataEntry* PROTOBUF_NONNULL ReplicateDataRequest::_internal_mutable_entry() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.entry_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::DataEntry>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::DataEntry>(GetArena()); _impl_.entry_ = reinterpret_cast<::dht::DataEntry*>(p); } return _impl_.entry_; } -inline ::dht::DataEntry* ReplicateDataRequest::mutable_entry() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::DataEntry* PROTOBUF_NONNULL ReplicateDataRequest::mutable_entry() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::DataEntry* _msg = _internal_mutable_entry(); // @@protoc_insertion_point(field_mutable:dht.ReplicateDataRequest.entry) return _msg; } -inline void ReplicateDataRequest::set_allocated_entry(::dht::DataEntry* value) { +inline void ReplicateDataRequest::set_allocated_entry(::dht::DataEntry* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::DataEntry*>(_impl_.entry_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entry_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::DataEntry*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.entry_ = reinterpret_cast<::dht::DataEntry*>(value); @@ -7501,65 +7695,77 @@ inline void ReplicateDataRequest::set_allocated_entry(::dht::DataEntry* value) { // bytes key = 1; inline void DataEntry::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& DataEntry::key() const +inline const ::std::string& DataEntry::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.DataEntry.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void DataEntry::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void DataEntry::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.DataEntry.key) } -inline std::string* DataEntry::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL DataEntry::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.key) return _s; } -inline const std::string& DataEntry::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& DataEntry::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void DataEntry::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void DataEntry::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* DataEntry::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL DataEntry::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* DataEntry::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE DataEntry::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void DataEntry::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.DataEntry.key) } // .google.protobuf.Any data = 2; inline bool DataEntry::has_data() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline const ::google::protobuf::Any& DataEntry::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -7567,76 +7773,78 @@ inline const ::google::protobuf::Any& DataEntry::data() const ABSL_ATTRIBUTE_LIF // @@protoc_insertion_point(field_get:dht.DataEntry.data) return _internal_data(); } -inline void DataEntry::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::unsafe_arena_set_allocated_data( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.DataEntry.data) } -inline ::google::protobuf::Any* DataEntry::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE DataEntry::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* released = _impl_.data_; _impl_.data_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* DataEntry::unsafe_arena_release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE DataEntry::unsafe_arena_release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.data) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } -inline ::google::protobuf::Any* DataEntry::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL DataEntry::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.data_; } -inline ::google::protobuf::Any* DataEntry::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL DataEntry::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.data) return _msg; } -inline void DataEntry::set_allocated_data(::google::protobuf::Any* value) { +inline void DataEntry::set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -7645,65 +7853,77 @@ inline void DataEntry::set_allocated_data(::google::protobuf::Any* value) { // bytes creator = 3; inline void DataEntry::clear_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& DataEntry::creator() const +inline const ::std::string& DataEntry::creator() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.DataEntry.creator) return _internal_creator(); } template -inline PROTOBUF_ALWAYS_INLINE void DataEntry::set_creator(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void DataEntry::set_creator(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.creator_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.DataEntry.creator) } -inline std::string* DataEntry::mutable_creator() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_creator(); +inline ::std::string* PROTOBUF_NONNULL DataEntry::mutable_creator() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_creator(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.creator) return _s; } -inline const std::string& DataEntry::_internal_creator() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& DataEntry::_internal_creator() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.creator_.Get(); } -inline void DataEntry::_internal_set_creator(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void DataEntry::_internal_set_creator(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.Set(value, GetArena()); } -inline std::string* DataEntry::_internal_mutable_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL DataEntry::_internal_mutable_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.creator_.Mutable( GetArena()); } -inline std::string* DataEntry::release_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE DataEntry::release_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.creator) - return _impl_.creator_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.creator_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.creator_.Set("", GetArena()); + } + return released; } -inline void DataEntry::set_allocated_creator(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::set_allocated_creator(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.creator_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.creator_.IsDefault()) { - _impl_.creator_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.creator_.IsDefault()) { + _impl_.creator_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.DataEntry.creator) } // .google.protobuf.Timestamp createdAt = 4; inline bool DataEntry::has_createdat() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.createdat_ != nullptr); return value; } inline const ::google::protobuf::Timestamp& DataEntry::_internal_createdat() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Timestamp* p = _impl_.createdat_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Timestamp_default_instance_); } @@ -7711,76 +7931,78 @@ inline const ::google::protobuf::Timestamp& DataEntry::createdat() const ABSL_AT // @@protoc_insertion_point(field_get:dht.DataEntry.createdAt) return _internal_createdat(); } -inline void DataEntry::unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::unsafe_arena_set_allocated_createdat( + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.DataEntry.createdAt) } -inline ::google::protobuf::Timestamp* DataEntry::release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* released = _impl_.createdat_; _impl_.createdat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Timestamp* DataEntry::unsafe_arena_release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::unsafe_arena_release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.createdAt) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* temp = _impl_.createdat_; _impl_.createdat_ = nullptr; return temp; } -inline ::google::protobuf::Timestamp* DataEntry::_internal_mutable_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::_internal_mutable_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena()); _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(p); } return _impl_.createdat_; } -inline ::google::protobuf::Timestamp* DataEntry::mutable_createdat() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::mutable_createdat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* _msg = _internal_mutable_createdat(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.createdAt) return _msg; } -inline void DataEntry::set_allocated_createdat(::google::protobuf::Timestamp* value) { +inline void DataEntry::set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); @@ -7789,12 +8011,12 @@ inline void DataEntry::set_allocated_createdat(::google::protobuf::Timestamp* va // .google.protobuf.Timestamp storedAt = 5; inline bool DataEntry::has_storedat() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.storedat_ != nullptr); return value; } inline const ::google::protobuf::Timestamp& DataEntry::_internal_storedat() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Timestamp* p = _impl_.storedat_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Timestamp_default_instance_); } @@ -7802,76 +8024,78 @@ inline const ::google::protobuf::Timestamp& DataEntry::storedat() const ABSL_ATT // @@protoc_insertion_point(field_get:dht.DataEntry.storedAt) return _internal_storedat(); } -inline void DataEntry::unsafe_arena_set_allocated_storedat(::google::protobuf::Timestamp* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::unsafe_arena_set_allocated_storedat( + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.storedat_); } _impl_.storedat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.DataEntry.storedAt) } -inline ::google::protobuf::Timestamp* DataEntry::release_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::release_storedat() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Timestamp* released = _impl_.storedat_; _impl_.storedat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Timestamp* DataEntry::unsafe_arena_release_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::unsafe_arena_release_storedat() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.storedAt) - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Timestamp* temp = _impl_.storedat_; _impl_.storedat_ = nullptr; return temp; } -inline ::google::protobuf::Timestamp* DataEntry::_internal_mutable_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::_internal_mutable_storedat() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.storedat_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena()); _impl_.storedat_ = reinterpret_cast<::google::protobuf::Timestamp*>(p); } return _impl_.storedat_; } -inline ::google::protobuf::Timestamp* DataEntry::mutable_storedat() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::mutable_storedat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Timestamp* _msg = _internal_mutable_storedat(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.storedAt) return _msg; } -inline void DataEntry::set_allocated_storedat(::google::protobuf::Timestamp* value) { +inline void DataEntry::set_allocated_storedat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.storedat_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.storedat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); @@ -7880,8 +8104,10 @@ inline void DataEntry::set_allocated_storedat(::google::protobuf::Timestamp* val // uint32 ttl = 6; inline void DataEntry::clear_ttl() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline ::uint32_t DataEntry::ttl() const { // @@protoc_insertion_point(field_get:dht.DataEntry.ttl) @@ -7889,22 +8115,24 @@ inline ::uint32_t DataEntry::ttl() const { } inline void DataEntry::set_ttl(::uint32_t value) { _internal_set_ttl(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:dht.DataEntry.ttl) } inline ::uint32_t DataEntry::_internal_ttl() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ttl_; } inline void DataEntry::_internal_set_ttl(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = value; } // bool stale = 7; inline void DataEntry::clear_stale() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stale_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline bool DataEntry::stale() const { // @@protoc_insertion_point(field_get:dht.DataEntry.stale) @@ -7912,22 +8140,24 @@ inline bool DataEntry::stale() const { } inline void DataEntry::set_stale(bool value) { _internal_set_stale(value); + SetHasBit(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_set:dht.DataEntry.stale) } inline bool DataEntry::_internal_stale() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.stale_; } inline void DataEntry::_internal_set_stale(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stale_ = value; } // bool deleted = 8; inline void DataEntry::clear_deleted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.deleted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000080U); } inline bool DataEntry::deleted() const { // @@protoc_insertion_point(field_get:dht.DataEntry.deleted) @@ -7935,15 +8165,15 @@ inline bool DataEntry::deleted() const { } inline void DataEntry::set_deleted(bool value) { _internal_set_deleted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000080U); // @@protoc_insertion_point(field_set:dht.DataEntry.deleted) } inline bool DataEntry::_internal_deleted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.deleted_; } inline void DataEntry::_internal_set_deleted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.deleted_ = value; } @@ -7953,107 +8183,131 @@ inline void DataEntry::_internal_set_deleted(bool value) { // bytes nodeId = 1; inline void ClosestPeersRequest::clear_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ClosestPeersRequest::nodeid() const +inline const ::std::string& ClosestPeersRequest::nodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestPeersRequest.nodeId) return _internal_nodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_nodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_nodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.nodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestPeersRequest.nodeId) } -inline std::string* ClosestPeersRequest::mutable_nodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nodeid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::mutable_nodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_nodeid(); // @@protoc_insertion_point(field_mutable:dht.ClosestPeersRequest.nodeId) return _s; } -inline const std::string& ClosestPeersRequest::_internal_nodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersRequest::_internal_nodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nodeid_.Get(); } -inline void ClosestPeersRequest::_internal_set_nodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersRequest::_internal_set_nodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.Set(value, GetArena()); } -inline std::string* ClosestPeersRequest::_internal_mutable_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::_internal_mutable_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nodeid_.Mutable( GetArena()); } -inline std::string* ClosestPeersRequest::release_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersRequest::release_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestPeersRequest.nodeId) - return _impl_.nodeid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.nodeid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nodeid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersRequest::set_allocated_nodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersRequest::set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.nodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nodeid_.IsDefault()) { - _impl_.nodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nodeid_.IsDefault()) { + _impl_.nodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestPeersRequest.nodeId) } // string requestId = 2; inline void ClosestPeersRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestPeersRequest::requestid() const +inline const ::std::string& ClosestPeersRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestPeersRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestPeersRequest.requestId) } -inline std::string* ClosestPeersRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestPeersRequest.requestId) return _s; } -inline const std::string& ClosestPeersRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestPeersRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestPeersRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestPeersRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestPeersRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestPeersRequest.requestId) } @@ -8069,18 +8323,21 @@ inline int ClosestPeersResponse::peers_size() const { return _internal_peers_size(); } inline void ClosestPeersResponse::clear_peers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.peers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* ClosestPeersResponse::mutable_peers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersResponse::mutable_peers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ClosestPeersResponse.peers) return _internal_mutable_peers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ClosestPeersResponse::mutable_peers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestPeersResponse::mutable_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ClosestPeersResponse.peers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_peers(); } inline const ::dht::PeerDescriptor& ClosestPeersResponse::peers(int index) const @@ -8088,9 +8345,13 @@ inline const ::dht::PeerDescriptor& ClosestPeersResponse::peers(int index) const // @@protoc_insertion_point(field_get:dht.ClosestPeersResponse.peers) return _internal_peers().Get(index); } -inline ::dht::PeerDescriptor* ClosestPeersResponse::add_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_peers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersResponse::add_peers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_peers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ClosestPeersResponse.peers) return _add; } @@ -8101,65 +8362,77 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Closes } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ClosestPeersResponse::_internal_peers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.peers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestPeersResponse::_internal_mutable_peers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.peers_; } // string requestId = 2; inline void ClosestPeersResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestPeersResponse::requestid() const +inline const ::std::string& ClosestPeersResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestPeersResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestPeersResponse.requestId) } -inline std::string* ClosestPeersResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestPeersResponse.requestId) return _s; } -inline const std::string& ClosestPeersResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestPeersResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestPeersResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestPeersResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestPeersResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestPeersResponse.requestId) } @@ -8169,107 +8442,131 @@ inline void ClosestPeersResponse::set_allocated_requestid(std::string* value) { // bytes ringId = 1; inline void ClosestRingPeersRequest::clear_ringid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ringid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ClosestRingPeersRequest::ringid() const +inline const ::std::string& ClosestRingPeersRequest::ringid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestRingPeersRequest.ringId) return _internal_ringid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_ringid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_ringid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.ringid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestRingPeersRequest.ringId) } -inline std::string* ClosestRingPeersRequest::mutable_ringid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_ringid(); +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::mutable_ringid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_ringid(); // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersRequest.ringId) return _s; } -inline const std::string& ClosestRingPeersRequest::_internal_ringid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestRingPeersRequest::_internal_ringid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ringid_.Get(); } -inline void ClosestRingPeersRequest::_internal_set_ringid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestRingPeersRequest::_internal_set_ringid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ringid_.Set(value, GetArena()); } -inline std::string* ClosestRingPeersRequest::_internal_mutable_ringid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::_internal_mutable_ringid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.ringid_.Mutable( GetArena()); } -inline std::string* ClosestRingPeersRequest::release_ringid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestRingPeersRequest::release_ringid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestRingPeersRequest.ringId) - return _impl_.ringid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.ringid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.ringid_.Set("", GetArena()); + } + return released; } -inline void ClosestRingPeersRequest::set_allocated_ringid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestRingPeersRequest::set_allocated_ringid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.ringid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ringid_.IsDefault()) { - _impl_.ringid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.ringid_.IsDefault()) { + _impl_.ringid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestRingPeersRequest.ringId) } // string requestId = 2; inline void ClosestRingPeersRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestRingPeersRequest::requestid() const +inline const ::std::string& ClosestRingPeersRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestRingPeersRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestRingPeersRequest.requestId) } -inline std::string* ClosestRingPeersRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersRequest.requestId) return _s; } -inline const std::string& ClosestRingPeersRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestRingPeersRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestRingPeersRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestRingPeersRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestRingPeersRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestRingPeersRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestRingPeersRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestRingPeersRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestRingPeersRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestRingPeersRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestRingPeersRequest.requestId) } @@ -8285,18 +8582,21 @@ inline int ClosestRingPeersResponse::leftpeers_size() const { return _internal_leftpeers_size(); } inline void ClosestRingPeersResponse::clear_leftpeers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.leftpeers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::mutable_leftpeers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_leftpeers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersResponse.leftPeers) return _internal_mutable_leftpeers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ClosestRingPeersResponse::mutable_leftpeers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_leftpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ClosestRingPeersResponse.leftPeers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_leftpeers(); } inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::leftpeers(int index) const @@ -8304,9 +8604,13 @@ inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::leftpeers(int inde // @@protoc_insertion_point(field_get:dht.ClosestRingPeersResponse.leftPeers) return _internal_leftpeers().Get(index); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::add_leftpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_leftpeers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::add_leftpeers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_leftpeers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ClosestRingPeersResponse.leftPeers) return _add; } @@ -8317,12 +8621,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Closes } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ClosestRingPeersResponse::_internal_leftpeers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.leftpeers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::_internal_mutable_leftpeers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.leftpeers_; } @@ -8334,18 +8638,21 @@ inline int ClosestRingPeersResponse::rightpeers_size() const { return _internal_rightpeers_size(); } inline void ClosestRingPeersResponse::clear_rightpeers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rightpeers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::mutable_rightpeers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_rightpeers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersResponse.rightPeers) return _internal_mutable_rightpeers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ClosestRingPeersResponse::mutable_rightpeers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_rightpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:dht.ClosestRingPeersResponse.rightPeers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_rightpeers(); } inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::rightpeers(int index) const @@ -8353,9 +8660,13 @@ inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::rightpeers(int ind // @@protoc_insertion_point(field_get:dht.ClosestRingPeersResponse.rightPeers) return _internal_rightpeers().Get(index); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::add_rightpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_rightpeers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::add_rightpeers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_rightpeers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:dht.ClosestRingPeersResponse.rightPeers) return _add; } @@ -8366,65 +8677,77 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Closes } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ClosestRingPeersResponse::_internal_rightpeers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rightpeers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::_internal_mutable_rightpeers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.rightpeers_; } // string requestId = 3; inline void ClosestRingPeersResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& ClosestRingPeersResponse::requestid() const +inline const ::std::string& ClosestRingPeersResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestRingPeersResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestRingPeersResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestRingPeersResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestRingPeersResponse.requestId) } -inline std::string* ClosestRingPeersResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersResponse.requestId) return _s; } -inline const std::string& ClosestRingPeersResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestRingPeersResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestRingPeersResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestRingPeersResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestRingPeersResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestRingPeersResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestRingPeersResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestRingPeersResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestRingPeersResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestRingPeersResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestRingPeersResponse.requestId) } @@ -8434,61 +8757,75 @@ inline void ClosestRingPeersResponse::set_allocated_requestid(std::string* value // string sessionId = 1; inline void RecursiveOperationRequest::clear_sessionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sessionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RecursiveOperationRequest::sessionid() const +inline const ::std::string& RecursiveOperationRequest::sessionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RecursiveOperationRequest.sessionId) return _internal_sessionid(); } template -inline PROTOBUF_ALWAYS_INLINE void RecursiveOperationRequest::set_sessionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RecursiveOperationRequest::set_sessionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.sessionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RecursiveOperationRequest.sessionId) } -inline std::string* RecursiveOperationRequest::mutable_sessionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_sessionid(); +inline ::std::string* PROTOBUF_NONNULL RecursiveOperationRequest::mutable_sessionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_sessionid(); // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationRequest.sessionId) return _s; } -inline const std::string& RecursiveOperationRequest::_internal_sessionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RecursiveOperationRequest::_internal_sessionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.sessionid_.Get(); } -inline void RecursiveOperationRequest::_internal_set_sessionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RecursiveOperationRequest::_internal_set_sessionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sessionid_.Set(value, GetArena()); } -inline std::string* RecursiveOperationRequest::_internal_mutable_sessionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RecursiveOperationRequest::_internal_mutable_sessionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.sessionid_.Mutable( GetArena()); } -inline std::string* RecursiveOperationRequest::release_sessionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RecursiveOperationRequest::release_sessionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RecursiveOperationRequest.sessionId) - return _impl_.sessionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.sessionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.sessionid_.Set("", GetArena()); + } + return released; } -inline void RecursiveOperationRequest::set_allocated_sessionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RecursiveOperationRequest::set_allocated_sessionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.sessionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sessionid_.IsDefault()) { - _impl_.sessionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.sessionid_.IsDefault()) { + _impl_.sessionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RecursiveOperationRequest.sessionId) } // .dht.RecursiveOperation operation = 2; inline void RecursiveOperationRequest::clear_operation() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.operation_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::dht::RecursiveOperation RecursiveOperationRequest::operation() const { // @@protoc_insertion_point(field_get:dht.RecursiveOperationRequest.operation) @@ -8496,15 +8833,15 @@ inline ::dht::RecursiveOperation RecursiveOperationRequest::operation() const { } inline void RecursiveOperationRequest::set_operation(::dht::RecursiveOperation value) { _internal_set_operation(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.RecursiveOperationRequest.operation) } inline ::dht::RecursiveOperation RecursiveOperationRequest::_internal_operation() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::RecursiveOperation>(_impl_.operation_); } inline void RecursiveOperationRequest::_internal_set_operation(::dht::RecursiveOperation value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.operation_ = value; } @@ -8520,18 +8857,21 @@ inline int RecursiveOperationResponse::closestconnectednodes_size() const { return _internal_closestconnectednodes_size(); } inline void RecursiveOperationResponse::clear_closestconnectednodes() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.closestconnectednodes_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::mutable_closestconnectednodes(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_closestconnectednodes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationResponse.closestConnectedNodes) return _internal_mutable_closestconnectednodes()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RecursiveOperationResponse::mutable_closestconnectednodes() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_closestconnectednodes() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.RecursiveOperationResponse.closestConnectedNodes) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_closestconnectednodes(); } inline const ::dht::PeerDescriptor& RecursiveOperationResponse::closestconnectednodes(int index) const @@ -8539,9 +8879,13 @@ inline const ::dht::PeerDescriptor& RecursiveOperationResponse::closestconnected // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.closestConnectedNodes) return _internal_closestconnectednodes().Get(index); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::add_closestconnectednodes() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_closestconnectednodes()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::add_closestconnectednodes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_closestconnectednodes()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.RecursiveOperationResponse.closestConnectedNodes) return _add; } @@ -8552,12 +8896,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Recurs } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RecursiveOperationResponse::_internal_closestconnectednodes() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.closestconnectednodes_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::_internal_mutable_closestconnectednodes() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.closestconnectednodes_; } @@ -8569,18 +8913,21 @@ inline int RecursiveOperationResponse::dataentries_size() const { return _internal_dataentries_size(); } inline void RecursiveOperationResponse::clear_dataentries() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dataentries_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -inline ::dht::DataEntry* RecursiveOperationResponse::mutable_dataentries(int index) +inline ::dht::DataEntry* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_dataentries(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationResponse.dataEntries) return _internal_mutable_dataentries()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* RecursiveOperationResponse::mutable_dataentries() +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_dataentries() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:dht.RecursiveOperationResponse.dataEntries) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_dataentries(); } inline const ::dht::DataEntry& RecursiveOperationResponse::dataentries(int index) const @@ -8588,9 +8935,13 @@ inline const ::dht::DataEntry& RecursiveOperationResponse::dataentries(int index // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.dataEntries) return _internal_dataentries().Get(index); } -inline ::dht::DataEntry* RecursiveOperationResponse::add_dataentries() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::DataEntry* _add = _internal_mutable_dataentries()->Add(); +inline ::dht::DataEntry* PROTOBUF_NONNULL RecursiveOperationResponse::add_dataentries() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::DataEntry* _add = + _internal_mutable_dataentries()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:dht.RecursiveOperationResponse.dataEntries) return _add; } @@ -8601,19 +8952,21 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& RecursiveOp } inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& RecursiveOperationResponse::_internal_dataentries() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.dataentries_; } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL RecursiveOperationResponse::_internal_mutable_dataentries() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.dataentries_; } // bool noCloserNodesFound = 3; inline void RecursiveOperationResponse::clear_noclosernodesfound() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.noclosernodesfound_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline bool RecursiveOperationResponse::noclosernodesfound() const { // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.noCloserNodesFound) @@ -8621,15 +8974,15 @@ inline bool RecursiveOperationResponse::noclosernodesfound() const { } inline void RecursiveOperationResponse::set_noclosernodesfound(bool value) { _internal_set_noclosernodesfound(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:dht.RecursiveOperationResponse.noCloserNodesFound) } inline bool RecursiveOperationResponse::_internal_noclosernodesfound() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.noclosernodesfound_; } inline void RecursiveOperationResponse::_internal_set_noclosernodesfound(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.noclosernodesfound_ = value; } @@ -8641,18 +8994,21 @@ inline int RecursiveOperationResponse::routingpath_size() const { return _internal_routingpath_size(); } inline void RecursiveOperationResponse::clear_routingpath() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.routingpath_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000004U); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::mutable_routingpath(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_routingpath(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationResponse.routingPath) return _internal_mutable_routingpath()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RecursiveOperationResponse::mutable_routingpath() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_mutable_list:dht.RecursiveOperationResponse.routingPath) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_routingpath(); } inline const ::dht::PeerDescriptor& RecursiveOperationResponse::routingpath(int index) const @@ -8660,9 +9016,13 @@ inline const ::dht::PeerDescriptor& RecursiveOperationResponse::routingpath(int // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.routingPath) return _internal_routingpath().Get(index); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::add_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_routingpath()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::add_routingpath() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_routingpath()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_add:dht.RecursiveOperationResponse.routingPath) return _add; } @@ -8673,12 +9033,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Recurs } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RecursiveOperationResponse::_internal_routingpath() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.routingpath_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::_internal_mutable_routingpath() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.routingpath_; } @@ -8688,54 +9048,66 @@ RecursiveOperationResponse::_internal_mutable_routingpath() { // string requestId = 1; inline void PingRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PingRequest::requestid() const +inline const ::std::string& PingRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PingRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void PingRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PingRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PingRequest.requestId) } -inline std::string* PingRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL PingRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.PingRequest.requestId) return _s; } -inline const std::string& PingRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PingRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void PingRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PingRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* PingRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PingRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* PingRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PingRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PingRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void PingRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PingRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PingRequest.requestId) } @@ -8745,54 +9117,66 @@ inline void PingRequest::set_allocated_requestid(std::string* value) { // string requestId = 1; inline void PingResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PingResponse::requestid() const +inline const ::std::string& PingResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PingResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void PingResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PingResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PingResponse.requestId) } -inline std::string* PingResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL PingResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.PingResponse.requestId) return _s; } -inline const std::string& PingResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PingResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void PingResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PingResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* PingResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PingResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* PingResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PingResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PingResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void PingResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PingResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PingResponse.requestId) } @@ -8806,61 +9190,75 @@ inline void PingResponse::set_allocated_requestid(std::string* value) { // bytes nodeId = 1; inline void PeerDescriptor::clear_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PeerDescriptor::nodeid() const +inline const ::std::string& PeerDescriptor::nodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.nodeId) return _internal_nodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_nodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_nodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.nodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.nodeId) } -inline std::string* PeerDescriptor::mutable_nodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nodeid(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_nodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_nodeid(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.nodeId) return _s; } -inline const std::string& PeerDescriptor::_internal_nodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_nodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nodeid_.Get(); } -inline void PeerDescriptor::_internal_set_nodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PeerDescriptor::_internal_set_nodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nodeid_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.nodeId) - return _impl_.nodeid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.nodeid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nodeid_.Set("", GetArena()); + } + return released; } -inline void PeerDescriptor::set_allocated_nodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.nodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nodeid_.IsDefault()) { - _impl_.nodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nodeid_.IsDefault()) { + _impl_.nodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PeerDescriptor.nodeId) } // .dht.NodeType type = 2; inline void PeerDescriptor::clear_type() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline ::dht::NodeType PeerDescriptor::type() const { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.type) @@ -8868,31 +9266,32 @@ inline ::dht::NodeType PeerDescriptor::type() const { } inline void PeerDescriptor::set_type(::dht::NodeType value) { _internal_set_type(value); + SetHasBit(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.type) } inline ::dht::NodeType PeerDescriptor::_internal_type() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::NodeType>(_impl_.type_); } inline void PeerDescriptor::_internal_set_type(::dht::NodeType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = value; } // .dht.ConnectivityMethod udp = 3; inline bool PeerDescriptor::has_udp() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.udp_ != nullptr); return value; } inline void PeerDescriptor::clear_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.udp_ != nullptr) _impl_.udp_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::dht::ConnectivityMethod& PeerDescriptor::_internal_udp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.udp_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -8900,76 +9299,78 @@ inline const ::dht::ConnectivityMethod& PeerDescriptor::udp() const ABSL_ATTRIBU // @@protoc_insertion_point(field_get:dht.PeerDescriptor.udp) return _internal_udp(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_udp(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_udp( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.udp_); } _impl_.udp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.PeerDescriptor.udp) } -inline ::dht::ConnectivityMethod* PeerDescriptor::release_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* released = _impl_.udp_; _impl_.udp_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.udp) - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* temp = _impl_.udp_; _impl_.udp_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* PeerDescriptor::_internal_mutable_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.udp_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.udp_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.udp_; } -inline ::dht::ConnectivityMethod* PeerDescriptor::mutable_udp() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_udp() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* _msg = _internal_mutable_udp(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.udp) return _msg; } -inline void PeerDescriptor::set_allocated_udp(::dht::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_udp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.udp_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.udp_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.udp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -8978,17 +9379,18 @@ inline void PeerDescriptor::set_allocated_udp(::dht::ConnectivityMethod* value) // .dht.ConnectivityMethod tcp = 4; inline bool PeerDescriptor::has_tcp() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.tcp_ != nullptr); return value; } inline void PeerDescriptor::clear_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.tcp_ != nullptr) _impl_.tcp_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline const ::dht::ConnectivityMethod& PeerDescriptor::_internal_tcp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.tcp_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -8996,76 +9398,78 @@ inline const ::dht::ConnectivityMethod& PeerDescriptor::tcp() const ABSL_ATTRIBU // @@protoc_insertion_point(field_get:dht.PeerDescriptor.tcp) return _internal_tcp(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_tcp(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_tcp( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tcp_); } _impl_.tcp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.PeerDescriptor.tcp) } -inline ::dht::ConnectivityMethod* PeerDescriptor::release_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::dht::ConnectivityMethod* released = _impl_.tcp_; _impl_.tcp_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.tcp) - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::dht::ConnectivityMethod* temp = _impl_.tcp_; _impl_.tcp_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* PeerDescriptor::_internal_mutable_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000008u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.tcp_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.tcp_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.tcp_; } -inline ::dht::ConnectivityMethod* PeerDescriptor::mutable_tcp() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_tcp() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::dht::ConnectivityMethod* _msg = _internal_mutable_tcp(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.tcp) return _msg; } -inline void PeerDescriptor::set_allocated_tcp(::dht::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_tcp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.tcp_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tcp_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.tcp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -9074,17 +9478,18 @@ inline void PeerDescriptor::set_allocated_tcp(::dht::ConnectivityMethod* value) // .dht.ConnectivityMethod websocket = 5; inline bool PeerDescriptor::has_websocket() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); PROTOBUF_ASSUME(!value || _impl_.websocket_ != nullptr); return value; } inline void PeerDescriptor::clear_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ != nullptr) _impl_.websocket_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline const ::dht::ConnectivityMethod& PeerDescriptor::_internal_websocket() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.websocket_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -9092,76 +9497,78 @@ inline const ::dht::ConnectivityMethod& PeerDescriptor::websocket() const ABSL_A // @@protoc_insertion_point(field_get:dht.PeerDescriptor.websocket) return _internal_websocket(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_websocket( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.PeerDescriptor.websocket) } -inline ::dht::ConnectivityMethod* PeerDescriptor::release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::ConnectivityMethod* released = _impl_.websocket_; _impl_.websocket_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.websocket) - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::ConnectivityMethod* temp = _impl_.websocket_; _impl_.websocket_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* PeerDescriptor::_internal_mutable_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000010u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.websocket_; } -inline ::dht::ConnectivityMethod* PeerDescriptor::mutable_websocket() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_websocket() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::ConnectivityMethod* _msg = _internal_mutable_websocket(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.websocket) return _msg; } -inline void PeerDescriptor::set_allocated_websocket(::dht::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.websocket_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000010u; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -9170,13 +9577,14 @@ inline void PeerDescriptor::set_allocated_websocket(::dht::ConnectivityMethod* v // optional uint32 region = 6; inline bool PeerDescriptor::has_region() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U); return value; } inline void PeerDescriptor::clear_region() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.region_ = 0u; - _impl_._has_bits_[0] &= ~0x00000020u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000080U); } inline ::uint32_t PeerDescriptor::region() const { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.region) @@ -9184,27 +9592,28 @@ inline ::uint32_t PeerDescriptor::region() const { } inline void PeerDescriptor::set_region(::uint32_t value) { _internal_set_region(value); + SetHasBit(_impl_._has_bits_[0], 0x00000080U); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.region) } inline ::uint32_t PeerDescriptor::_internal_region() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.region_; } inline void PeerDescriptor::_internal_set_region(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000020u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.region_ = value; } // optional uint32 ipAddress = 7; inline bool PeerDescriptor::has_ipaddress() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U); return value; } inline void PeerDescriptor::clear_ipaddress() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000100U); } inline ::uint32_t PeerDescriptor::ipaddress() const { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.ipAddress) @@ -9212,157 +9621,153 @@ inline ::uint32_t PeerDescriptor::ipaddress() const { } inline void PeerDescriptor::set_ipaddress(::uint32_t value) { _internal_set_ipaddress(value); + SetHasBit(_impl_._has_bits_[0], 0x00000100U); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.ipAddress) } inline ::uint32_t PeerDescriptor::_internal_ipaddress() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ipaddress_; } inline void PeerDescriptor::_internal_set_ipaddress(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000040u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = value; } // optional bytes publicKey = 8; inline bool PeerDescriptor::has_publickey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void PeerDescriptor::clear_publickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.publickey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& PeerDescriptor::publickey() const +inline const ::std::string& PeerDescriptor::publickey() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.publicKey) return _internal_publickey(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_publickey(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_publickey(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.publickey_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.publicKey) } -inline std::string* PeerDescriptor::mutable_publickey() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_publickey(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_publickey() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_publickey(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.publicKey) return _s; } -inline const std::string& PeerDescriptor::_internal_publickey() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_publickey() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.publickey_.Get(); } -inline void PeerDescriptor::_internal_set_publickey(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void PeerDescriptor::_internal_set_publickey(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.publickey_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_publickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_publickey() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.publickey_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_publickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_publickey() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.publicKey) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); auto* released = _impl_.publickey_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.publickey_.Set("", GetArena()); + } return released; } -inline void PeerDescriptor::set_allocated_publickey(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_publickey(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.publickey_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PeerDescriptor.publicKey) } // optional bytes signature = 9; inline bool PeerDescriptor::has_signature() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void PeerDescriptor::clear_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& PeerDescriptor::signature() const +inline const ::std::string& PeerDescriptor::signature() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.signature) return _internal_signature(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_signature(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_signature(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.signature_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.signature) } -inline std::string* PeerDescriptor::mutable_signature() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_signature(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_signature() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_signature(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.signature) return _s; } -inline const std::string& PeerDescriptor::_internal_signature() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_signature() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.signature_.Get(); } -inline void PeerDescriptor::_internal_set_signature(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline void PeerDescriptor::_internal_set_signature(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signature_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_signature() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.signature_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_signature() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.signature) - if ((_impl_._has_bits_[0] & 0x00000002u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); auto* released = _impl_.signature_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.signature_.Set("", GetArena()); + } return released; } -inline void PeerDescriptor::set_allocated_signature(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_signature(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.signature_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PeerDescriptor.signature) } @@ -9372,8 +9777,10 @@ inline void PeerDescriptor::set_allocated_signature(std::string* value) { // uint32 port = 1; inline void ConnectivityMethod::clear_port() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::uint32_t ConnectivityMethod::port() const { // @@protoc_insertion_point(field_get:dht.ConnectivityMethod.port) @@ -9381,75 +9788,89 @@ inline ::uint32_t ConnectivityMethod::port() const { } inline void ConnectivityMethod::set_port(::uint32_t value) { _internal_set_port(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.ConnectivityMethod.port) } inline ::uint32_t ConnectivityMethod::_internal_port() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.port_; } inline void ConnectivityMethod::_internal_set_port(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = value; } // string host = 2; inline void ConnectivityMethod::clear_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityMethod::host() const +inline const ::std::string& ConnectivityMethod::host() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityMethod.host) return _internal_host(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityMethod::set_host(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityMethod::set_host(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.host_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityMethod.host) } -inline std::string* ConnectivityMethod::mutable_host() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_host(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityMethod::mutable_host() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_host(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityMethod.host) return _s; } -inline const std::string& ConnectivityMethod::_internal_host() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityMethod::_internal_host() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.host_.Get(); } -inline void ConnectivityMethod::_internal_set_host(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityMethod::_internal_set_host(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.Set(value, GetArena()); } -inline std::string* ConnectivityMethod::_internal_mutable_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityMethod::_internal_mutable_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.host_.Mutable( GetArena()); } -inline std::string* ConnectivityMethod::release_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityMethod::release_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityMethod.host) - return _impl_.host_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.host_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.host_.Set("", GetArena()); + } + return released; } -inline void ConnectivityMethod::set_allocated_host(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityMethod::set_allocated_host(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.host_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.host_.IsDefault()) { - _impl_.host_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityMethod.host) } // bool tls = 3; inline void ConnectivityMethod::clear_tls() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline bool ConnectivityMethod::tls() const { // @@protoc_insertion_point(field_get:dht.ConnectivityMethod.tls) @@ -9457,15 +9878,15 @@ inline bool ConnectivityMethod::tls() const { } inline void ConnectivityMethod::set_tls(bool value) { _internal_set_tls(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:dht.ConnectivityMethod.tls) } inline bool ConnectivityMethod::_internal_tls() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tls_; } inline void ConnectivityMethod::_internal_set_tls(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = value; } @@ -9475,70 +9896,83 @@ inline void ConnectivityMethod::_internal_set_tls(bool value) { // string requestId = 1; inline void RouteMessageWrapper::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& RouteMessageWrapper::requestid() const +inline const ::std::string& RouteMessageWrapper::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.requestId) } -inline std::string* RouteMessageWrapper::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.requestId) return _s; } -inline const std::string& RouteMessageWrapper::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageWrapper::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RouteMessageWrapper::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageWrapper::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RouteMessageWrapper::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RouteMessageWrapper::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageWrapper::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RouteMessageWrapper::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RouteMessageWrapper.requestId) } // .dht.PeerDescriptor sourcePeer = 2; inline bool RouteMessageWrapper::has_sourcepeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); PROTOBUF_ASSUME(!value || _impl_.sourcepeer_ != nullptr); return value; } inline void RouteMessageWrapper::clear_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ != nullptr) _impl_.sourcepeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline const ::dht::PeerDescriptor& RouteMessageWrapper::_internal_sourcepeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcepeer_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -9546,76 +9980,78 @@ inline const ::dht::PeerDescriptor& RouteMessageWrapper::sourcepeer() const ABSL // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.sourcePeer) return _internal_sourcepeer(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_sourcepeer(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_sourcepeer( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } _impl_.sourcepeer_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.RouteMessageWrapper.sourcePeer) } -inline ::dht::PeerDescriptor* RouteMessageWrapper::release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::PeerDescriptor* released = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* RouteMessageWrapper::unsafe_arena_release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.sourcePeer) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::PeerDescriptor* temp = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* RouteMessageWrapper::_internal_mutable_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcepeer_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcepeer_; } -inline ::dht::PeerDescriptor* RouteMessageWrapper::mutable_sourcepeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_sourcepeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcepeer(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.sourcePeer) return _msg; } -inline void RouteMessageWrapper::set_allocated_sourcepeer(::dht::PeerDescriptor* value) { +inline void RouteMessageWrapper::set_allocated_sourcepeer(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcepeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } _impl_.sourcepeer_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -9624,70 +10060,83 @@ inline void RouteMessageWrapper::set_allocated_sourcepeer(::dht::PeerDescriptor* // bytes target = 3; inline void RouteMessageWrapper::clear_target() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -inline const std::string& RouteMessageWrapper::target() const +inline const ::std::string& RouteMessageWrapper::target() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.target) return _internal_target(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_target(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_target(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); _impl_.target_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.target) } -inline std::string* RouteMessageWrapper::mutable_target() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_target(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_target() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + ::std::string* _s = _internal_mutable_target(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.target) return _s; } -inline const std::string& RouteMessageWrapper::_internal_target() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageWrapper::_internal_target() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.target_.Get(); } -inline void RouteMessageWrapper::_internal_set_target(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageWrapper::_internal_set_target(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.Set(value, GetArena()); } -inline std::string* RouteMessageWrapper::_internal_mutable_target() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_target() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.target_.Mutable( GetArena()); } -inline std::string* RouteMessageWrapper::release_target() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageWrapper::release_target() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.target) - return _impl_.target_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + auto* released = _impl_.target_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.target_.Set("", GetArena()); + } + return released; } -inline void RouteMessageWrapper::set_allocated_target(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::set_allocated_target(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + } _impl_.target_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.target_.IsDefault()) { - _impl_.target_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.target_.IsDefault()) { + _impl_.target_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RouteMessageWrapper.target) } // .dht.Message message = 4; inline bool RouteMessageWrapper::has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U); PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); return value; } inline void RouteMessageWrapper::clear_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline const ::dht::Message& RouteMessageWrapper::_internal_message() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::Message* p = _impl_.message_; return p != nullptr ? *p : reinterpret_cast(::dht::_Message_default_instance_); } @@ -9695,76 +10144,78 @@ inline const ::dht::Message& RouteMessageWrapper::message() const ABSL_ATTRIBUTE // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.message) return _internal_message(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_message(::dht::Message* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_message( + ::dht::Message* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.message_); } _impl_.message_ = reinterpret_cast<::dht::Message*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000040U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.RouteMessageWrapper.message) } -inline ::dht::Message* RouteMessageWrapper::release_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::Message* PROTOBUF_NULLABLE RouteMessageWrapper::release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); ::dht::Message* released = _impl_.message_; _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::Message* RouteMessageWrapper::unsafe_arena_release_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::Message* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.message) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); ::dht::Message* temp = _impl_.message_; _impl_.message_ = nullptr; return temp; } -inline ::dht::Message* RouteMessageWrapper::_internal_mutable_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::dht::Message* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::Message>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::Message>(GetArena()); _impl_.message_ = reinterpret_cast<::dht::Message*>(p); } return _impl_.message_; } -inline ::dht::Message* RouteMessageWrapper::mutable_message() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::Message* PROTOBUF_NONNULL RouteMessageWrapper::mutable_message() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000040U); ::dht::Message* _msg = _internal_mutable_message(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.message) return _msg; } -inline void RouteMessageWrapper::set_allocated_message(::dht::Message* value) { +inline void RouteMessageWrapper::set_allocated_message(::dht::Message* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::Message*>(_impl_.message_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.message_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::Message*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000040U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); } _impl_.message_ = reinterpret_cast<::dht::Message*>(value); @@ -9779,18 +10230,21 @@ inline int RouteMessageWrapper::reachablethrough_size() const { return _internal_reachablethrough_size(); } inline void RouteMessageWrapper::clear_reachablethrough() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.reachablethrough_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::mutable_reachablethrough(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_reachablethrough(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.reachableThrough) return _internal_mutable_reachablethrough()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RouteMessageWrapper::mutable_reachablethrough() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::mutable_reachablethrough() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.RouteMessageWrapper.reachableThrough) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_reachablethrough(); } inline const ::dht::PeerDescriptor& RouteMessageWrapper::reachablethrough(int index) const @@ -9798,9 +10252,13 @@ inline const ::dht::PeerDescriptor& RouteMessageWrapper::reachablethrough(int in // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.reachableThrough) return _internal_reachablethrough().Get(index); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::add_reachablethrough() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_reachablethrough()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::add_reachablethrough() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_reachablethrough()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.reachableThrough) return _add; } @@ -9811,12 +10269,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteM } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteMessageWrapper::_internal_reachablethrough() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.reachablethrough_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_reachablethrough() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.reachablethrough_; } @@ -9828,18 +10286,21 @@ inline int RouteMessageWrapper::routingpath_size() const { return _internal_routingpath_size(); } inline void RouteMessageWrapper::clear_routingpath() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.routingpath_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::mutable_routingpath(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_routingpath(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.routingPath) return _internal_mutable_routingpath()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RouteMessageWrapper::mutable_routingpath() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::mutable_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:dht.RouteMessageWrapper.routingPath) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_routingpath(); } inline const ::dht::PeerDescriptor& RouteMessageWrapper::routingpath(int index) const @@ -9847,9 +10308,13 @@ inline const ::dht::PeerDescriptor& RouteMessageWrapper::routingpath(int index) // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.routingPath) return _internal_routingpath().Get(index); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::add_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_routingpath()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::add_routingpath() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_routingpath()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.routingPath) return _add; } @@ -9860,12 +10325,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteM } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteMessageWrapper::_internal_routingpath() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.routingpath_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_routingpath() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.routingpath_; } @@ -9877,96 +10342,67 @@ inline int RouteMessageWrapper::parallelrootnodeids_size() const { return _internal_parallelrootnodeids_size(); } inline void RouteMessageWrapper::clear_parallelrootnodeids() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.parallelrootnodeids_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000004U); } -inline std::string* RouteMessageWrapper::add_parallelrootnodeids() +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::add_parallelrootnodeids() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - std::string* _s = _internal_mutable_parallelrootnodeids()->Add(); + ::google::protobuf::internal::TSanWrite(&_impl_); + ::std::string* _s = + _internal_mutable_parallelrootnodeids()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_add_mutable:dht.RouteMessageWrapper.parallelRootNodeIds) return _s; } -inline const std::string& RouteMessageWrapper::parallelrootnodeids(int index) const +inline const ::std::string& RouteMessageWrapper::parallelrootnodeids(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.parallelRootNodeIds) return _internal_parallelrootnodeids().Get(index); } -inline std::string* RouteMessageWrapper::mutable_parallelrootnodeids(int index) +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_parallelrootnodeids(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.parallelRootNodeIds) return _internal_mutable_parallelrootnodeids()->Mutable(index); } -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, const std::string& value) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, std::string&& value) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(std::move(value)); +template +inline void RouteMessageWrapper::set_parallelrootnodeids(int index, Arg_&& value, Args_... args) { + ::google::protobuf::internal::AssignToString(*_internal_mutable_parallelrootnodeids()->Mutable(index), ::std::forward(value), + args... ); // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.parallelRootNodeIds) } -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, const char* value) { - ABSL_DCHECK(value != nullptr); - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, const char* value, - std::size_t size) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, absl::string_view value) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(value.data(), - value.size()); - // @@protoc_insertion_point(field_set_string_piece:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign(value); - // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(std::string&& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add(std::move(value)); +template +inline void RouteMessageWrapper::add_parallelrootnodeids(Arg_&& value, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::google::protobuf::internal::AddToRepeatedPtrField( + ::google::protobuf::MessageLite::internal_visibility(), GetArena(), + *_internal_mutable_parallelrootnodeids(), ::std::forward(value), + args... ); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.parallelRootNodeIds) } -inline void RouteMessageWrapper::add_parallelrootnodeids(const char* value) { - ABSL_DCHECK(value != nullptr); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign(value); - // @@protoc_insertion_point(field_add_char:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(const char* value, std::size_t size) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(absl::string_view value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign(value.data(), value.size()); - // @@protoc_insertion_point(field_add_string_piece:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline const ::google::protobuf::RepeatedPtrField& -RouteMessageWrapper::parallelrootnodeids() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::RepeatedPtrField<::std::string>& RouteMessageWrapper::parallelrootnodeids() + const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:dht.RouteMessageWrapper.parallelRootNodeIds) return _internal_parallelrootnodeids(); } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL RouteMessageWrapper::mutable_parallelrootnodeids() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_mutable_list:dht.RouteMessageWrapper.parallelRootNodeIds) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_parallelrootnodeids(); } -inline const ::google::protobuf::RepeatedPtrField& +inline const ::google::protobuf::RepeatedPtrField<::std::string>& RouteMessageWrapper::_internal_parallelrootnodeids() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.parallelrootnodeids_; } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_parallelrootnodeids() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.parallelrootnodeids_; } @@ -9976,66 +10412,79 @@ RouteMessageWrapper::_internal_mutable_parallelrootnodeids() { // string requestId = 1; inline void RouteMessageAck::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RouteMessageAck::requestid() const +inline const ::std::string& RouteMessageAck::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageAck.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RouteMessageAck.requestId) } -inline std::string* RouteMessageAck::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageAck.requestId) return _s; } -inline const std::string& RouteMessageAck::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageAck::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RouteMessageAck::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageAck::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RouteMessageAck::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RouteMessageAck::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageAck::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageAck.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RouteMessageAck::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageAck::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RouteMessageAck.requestId) } // optional .dht.RouteMessageError error = 2; inline bool RouteMessageAck::has_error() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void RouteMessageAck::clear_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::dht::RouteMessageError RouteMessageAck::error() const { // @@protoc_insertion_point(field_get:dht.RouteMessageAck.error) @@ -10043,15 +10492,15 @@ inline ::dht::RouteMessageError RouteMessageAck::error() const { } inline void RouteMessageAck::set_error(::dht::RouteMessageError value) { _internal_set_error(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.RouteMessageAck.error) } inline ::dht::RouteMessageError RouteMessageAck::_internal_error() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::RouteMessageError>(_impl_.error_); } inline void RouteMessageAck::_internal_set_error(::dht::RouteMessageError value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = value; } @@ -10061,8 +10510,10 @@ inline void RouteMessageAck::_internal_set_error(::dht::RouteMessageError value) // uint32 port = 1; inline void ConnectivityRequest::clear_port() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::uint32_t ConnectivityRequest::port() const { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.port) @@ -10070,22 +10521,24 @@ inline ::uint32_t ConnectivityRequest::port() const { } inline void ConnectivityRequest::set_port(::uint32_t value) { _internal_set_port(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.port) } inline ::uint32_t ConnectivityRequest::_internal_port() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.port_; } inline void ConnectivityRequest::_internal_set_port(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = value; } // bool tls = 2; inline void ConnectivityRequest::clear_tls() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline bool ConnectivityRequest::tls() const { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.tls) @@ -10093,93 +10546,93 @@ inline bool ConnectivityRequest::tls() const { } inline void ConnectivityRequest::set_tls(bool value) { _internal_set_tls(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.tls) } inline bool ConnectivityRequest::_internal_tls() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tls_; } inline void ConnectivityRequest::_internal_set_tls(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = value; } // optional string host = 3; inline bool ConnectivityRequest::has_host() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); return value; } inline void ConnectivityRequest::clear_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityRequest::host() const +inline const ::std::string& ConnectivityRequest::host() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.host) return _internal_host(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityRequest::set_host(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void ConnectivityRequest::set_host(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.host_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.host) } -inline std::string* ConnectivityRequest::mutable_host() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_host(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityRequest::mutable_host() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_host(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityRequest.host) return _s; } -inline const std::string& ConnectivityRequest::_internal_host() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityRequest::_internal_host() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.host_.Get(); } -inline void ConnectivityRequest::_internal_set_host(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void ConnectivityRequest::_internal_set_host(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.Set(value, GetArena()); } -inline std::string* ConnectivityRequest::_internal_mutable_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL ConnectivityRequest::_internal_mutable_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.host_.Mutable( GetArena()); } -inline std::string* ConnectivityRequest::release_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityRequest::release_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityRequest.host) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); auto* released = _impl_.host_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.host_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.host_.Set("", GetArena()); + } return released; } -inline void ConnectivityRequest::set_allocated_host(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityRequest::set_allocated_host(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.host_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.host_.IsDefault()) { - _impl_.host_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityRequest.host) } // bool allowSelfSignedCertificate = 4; inline void ConnectivityRequest::clear_allowselfsignedcertificate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.allowselfsignedcertificate_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline bool ConnectivityRequest::allowselfsignedcertificate() const { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.allowSelfSignedCertificate) @@ -10187,15 +10640,15 @@ inline bool ConnectivityRequest::allowselfsignedcertificate() const { } inline void ConnectivityRequest::set_allowselfsignedcertificate(bool value) { _internal_set_allowselfsignedcertificate(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.allowSelfSignedCertificate) } inline bool ConnectivityRequest::_internal_allowselfsignedcertificate() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.allowselfsignedcertificate_; } inline void ConnectivityRequest::_internal_set_allowselfsignedcertificate(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.allowselfsignedcertificate_ = value; } @@ -10205,123 +10658,148 @@ inline void ConnectivityRequest::_internal_set_allowselfsignedcertificate(bool v // string host = 1; inline void ConnectivityResponse::clear_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityResponse::host() const +inline const ::std::string& ConnectivityResponse::host() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.host) return _internal_host(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_host(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_host(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.host_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.host) } -inline std::string* ConnectivityResponse::mutable_host() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_host(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::mutable_host() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_host(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.host) return _s; } -inline const std::string& ConnectivityResponse::_internal_host() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityResponse::_internal_host() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.host_.Get(); } -inline void ConnectivityResponse::_internal_set_host(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityResponse::_internal_set_host(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.Set(value, GetArena()); } -inline std::string* ConnectivityResponse::_internal_mutable_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.host_.Mutable( GetArena()); } -inline std::string* ConnectivityResponse::release_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityResponse::release_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.host) - return _impl_.host_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.host_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.host_.Set("", GetArena()); + } + return released; } -inline void ConnectivityResponse::set_allocated_host(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::set_allocated_host(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.host_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.host_.IsDefault()) { - _impl_.host_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityResponse.host) } // string natType = 2; inline void ConnectivityResponse::clear_nattype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nattype_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ConnectivityResponse::nattype() const +inline const ::std::string& ConnectivityResponse::nattype() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.natType) return _internal_nattype(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_nattype(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_nattype(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.nattype_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.natType) } -inline std::string* ConnectivityResponse::mutable_nattype() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nattype(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::mutable_nattype() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_nattype(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.natType) return _s; } -inline const std::string& ConnectivityResponse::_internal_nattype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityResponse::_internal_nattype() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nattype_.Get(); } -inline void ConnectivityResponse::_internal_set_nattype(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityResponse::_internal_set_nattype(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nattype_.Set(value, GetArena()); } -inline std::string* ConnectivityResponse::_internal_mutable_nattype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_nattype() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nattype_.Mutable( GetArena()); } -inline std::string* ConnectivityResponse::release_nattype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityResponse::release_nattype() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.natType) - return _impl_.nattype_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.nattype_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nattype_.Set("", GetArena()); + } + return released; } -inline void ConnectivityResponse::set_allocated_nattype(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::set_allocated_nattype(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.nattype_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nattype_.IsDefault()) { - _impl_.nattype_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nattype_.IsDefault()) { + _impl_.nattype_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityResponse.natType) } // .dht.ConnectivityMethod websocket = 3; inline bool ConnectivityResponse::has_websocket() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.websocket_ != nullptr); return value; } inline void ConnectivityResponse::clear_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ != nullptr) _impl_.websocket_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::dht::ConnectivityMethod& ConnectivityResponse::_internal_websocket() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.websocket_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -10329,76 +10807,78 @@ inline const ::dht::ConnectivityMethod& ConnectivityResponse::websocket() const // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.websocket) return _internal_websocket(); } -inline void ConnectivityResponse::unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::unsafe_arena_set_allocated_websocket( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.ConnectivityResponse.websocket) } -inline ::dht::ConnectivityMethod* ConnectivityResponse::release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE ConnectivityResponse::release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* released = _impl_.websocket_; _impl_.websocket_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* ConnectivityResponse::unsafe_arena_release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE ConnectivityResponse::unsafe_arena_release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.websocket) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* temp = _impl_.websocket_; _impl_.websocket_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* ConnectivityResponse::_internal_mutable_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.websocket_; } -inline ::dht::ConnectivityMethod* ConnectivityResponse::mutable_websocket() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL ConnectivityResponse::mutable_websocket() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* _msg = _internal_mutable_websocket(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.websocket) return _msg; } -inline void ConnectivityResponse::set_allocated_websocket(::dht::ConnectivityMethod* value) { +inline void ConnectivityResponse::set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.websocket_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -10407,8 +10887,10 @@ inline void ConnectivityResponse::set_allocated_websocket(::dht::ConnectivityMet // uint32 ipAddress = 4; inline void ConnectivityResponse::clear_ipaddress() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline ::uint32_t ConnectivityResponse::ipaddress() const { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.ipAddress) @@ -10416,80 +10898,93 @@ inline ::uint32_t ConnectivityResponse::ipaddress() const { } inline void ConnectivityResponse::set_ipaddress(::uint32_t value) { _internal_set_ipaddress(value); + SetHasBit(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.ipAddress) } inline ::uint32_t ConnectivityResponse::_internal_ipaddress() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ipaddress_; } inline void ConnectivityResponse::_internal_set_ipaddress(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = value; } // string version = 5; inline void ConnectivityResponse::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& ConnectivityResponse::version() const +inline const ::std::string& ConnectivityResponse::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.version) } -inline std::string* ConnectivityResponse::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.version) return _s; } -inline const std::string& ConnectivityResponse::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityResponse::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void ConnectivityResponse::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityResponse::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* ConnectivityResponse::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* ConnectivityResponse::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityResponse::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void ConnectivityResponse::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityResponse.version) } // optional double latitude = 6; inline bool ConnectivityResponse::has_latitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); return value; } inline void ConnectivityResponse::clear_latitude() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline double ConnectivityResponse::latitude() const { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.latitude) @@ -10497,27 +10992,28 @@ inline double ConnectivityResponse::latitude() const { } inline void ConnectivityResponse::set_latitude(double value) { _internal_set_latitude(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.latitude) } inline double ConnectivityResponse::_internal_latitude() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.latitude_; } inline void ConnectivityResponse::_internal_set_latitude(double value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latitude_ = value; } // optional double longitude = 7; inline bool ConnectivityResponse::has_longitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); return value; } inline void ConnectivityResponse::clear_longitude() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.longitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline double ConnectivityResponse::longitude() const { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.longitude) @@ -10525,15 +11021,15 @@ inline double ConnectivityResponse::longitude() const { } inline void ConnectivityResponse::set_longitude(double value) { _internal_set_longitude(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.longitude) } inline double ConnectivityResponse::_internal_longitude() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.longitude_; } inline void ConnectivityResponse::_internal_set_longitude(double value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.longitude_ = value; } @@ -10543,17 +11039,18 @@ inline void ConnectivityResponse::_internal_set_longitude(double value) { // .dht.PeerDescriptor sourcePeerDescriptor = 1; inline bool HandshakeRequest::has_sourcepeerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.sourcepeerdescriptor_ != nullptr); return value; } inline void HandshakeRequest::clear_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ != nullptr) _impl_.sourcepeerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::dht::PeerDescriptor& HandshakeRequest::_internal_sourcepeerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcepeerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -10561,76 +11058,78 @@ inline const ::dht::PeerDescriptor& HandshakeRequest::sourcepeerdescriptor() con // @@protoc_insertion_point(field_get:dht.HandshakeRequest.sourcePeerDescriptor) return _internal_sourcepeerdescriptor(); } -inline void HandshakeRequest::unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeRequest::unsafe_arena_set_allocated_sourcepeerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.HandshakeRequest.sourcePeerDescriptor) } -inline ::dht::PeerDescriptor* HandshakeRequest::release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* released = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* HandshakeRequest::unsafe_arena_release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::unsafe_arena_release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeRequest.sourcePeerDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* temp = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* HandshakeRequest::_internal_mutable_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::_internal_mutable_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcepeerdescriptor_; } -inline ::dht::PeerDescriptor* HandshakeRequest::mutable_sourcepeerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::mutable_sourcepeerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcepeerdescriptor(); // @@protoc_insertion_point(field_mutable:dht.HandshakeRequest.sourcePeerDescriptor) return _msg; } -inline void HandshakeRequest::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { +inline void HandshakeRequest::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcepeerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -10639,17 +11138,18 @@ inline void HandshakeRequest::set_allocated_sourcepeerdescriptor(::dht::PeerDesc // optional .dht.PeerDescriptor targetPeerDescriptor = 2; inline bool HandshakeRequest::has_targetpeerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.targetpeerdescriptor_ != nullptr); return value; } inline void HandshakeRequest::clear_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetpeerdescriptor_ != nullptr) _impl_.targetpeerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::dht::PeerDescriptor& HandshakeRequest::_internal_targetpeerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.targetpeerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -10657,76 +11157,78 @@ inline const ::dht::PeerDescriptor& HandshakeRequest::targetpeerdescriptor() con // @@protoc_insertion_point(field_get:dht.HandshakeRequest.targetPeerDescriptor) return _internal_targetpeerdescriptor(); } -inline void HandshakeRequest::unsafe_arena_set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeRequest::unsafe_arena_set_allocated_targetpeerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetpeerdescriptor_); } _impl_.targetpeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.HandshakeRequest.targetPeerDescriptor) } -inline ::dht::PeerDescriptor* HandshakeRequest::release_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::release_targetpeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* released = _impl_.targetpeerdescriptor_; _impl_.targetpeerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* HandshakeRequest::unsafe_arena_release_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::unsafe_arena_release_targetpeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeRequest.targetPeerDescriptor) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* temp = _impl_.targetpeerdescriptor_; _impl_.targetpeerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* HandshakeRequest::_internal_mutable_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::_internal_mutable_targetpeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetpeerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.targetpeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.targetpeerdescriptor_; } -inline ::dht::PeerDescriptor* HandshakeRequest::mutable_targetpeerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::mutable_targetpeerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* _msg = _internal_mutable_targetpeerdescriptor(); // @@protoc_insertion_point(field_mutable:dht.HandshakeRequest.targetPeerDescriptor) return _msg; } -inline void HandshakeRequest::set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value) { +inline void HandshakeRequest::set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.targetpeerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetpeerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.targetpeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -10735,54 +11237,66 @@ inline void HandshakeRequest::set_allocated_targetpeerdescriptor(::dht::PeerDesc // string version = 3; inline void HandshakeRequest::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HandshakeRequest::version() const +inline const ::std::string& HandshakeRequest::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.HandshakeRequest.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void HandshakeRequest::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HandshakeRequest::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.HandshakeRequest.version) } -inline std::string* HandshakeRequest::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL HandshakeRequest::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:dht.HandshakeRequest.version) return _s; } -inline const std::string& HandshakeRequest::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HandshakeRequest::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void HandshakeRequest::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HandshakeRequest::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* HandshakeRequest::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HandshakeRequest::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* HandshakeRequest::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HandshakeRequest::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeRequest.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void HandshakeRequest::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeRequest::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.HandshakeRequest.version) } @@ -10792,17 +11306,18 @@ inline void HandshakeRequest::set_allocated_version(std::string* value) { // .dht.PeerDescriptor sourcePeerDescriptor = 1; inline bool HandshakeResponse::has_sourcepeerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.sourcepeerdescriptor_ != nullptr); return value; } inline void HandshakeResponse::clear_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ != nullptr) _impl_.sourcepeerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::dht::PeerDescriptor& HandshakeResponse::_internal_sourcepeerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcepeerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -10810,76 +11325,78 @@ inline const ::dht::PeerDescriptor& HandshakeResponse::sourcepeerdescriptor() co // @@protoc_insertion_point(field_get:dht.HandshakeResponse.sourcePeerDescriptor) return _internal_sourcepeerdescriptor(); } -inline void HandshakeResponse::unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeResponse::unsafe_arena_set_allocated_sourcepeerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.HandshakeResponse.sourcePeerDescriptor) } -inline ::dht::PeerDescriptor* HandshakeResponse::release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeResponse::release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* released = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* HandshakeResponse::unsafe_arena_release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeResponse::unsafe_arena_release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeResponse.sourcePeerDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* temp = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* HandshakeResponse::_internal_mutable_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeResponse::_internal_mutable_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcepeerdescriptor_; } -inline ::dht::PeerDescriptor* HandshakeResponse::mutable_sourcepeerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeResponse::mutable_sourcepeerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcepeerdescriptor(); // @@protoc_insertion_point(field_mutable:dht.HandshakeResponse.sourcePeerDescriptor) return _msg; } -inline void HandshakeResponse::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { +inline void HandshakeResponse::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcepeerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -10888,13 +11405,14 @@ inline void HandshakeResponse::set_allocated_sourcepeerdescriptor(::dht::PeerDes // optional .dht.HandshakeError error = 2; inline bool HandshakeResponse::has_error() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void HandshakeResponse::clear_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline ::dht::HandshakeError HandshakeResponse::error() const { // @@protoc_insertion_point(field_get:dht.HandshakeResponse.error) @@ -10902,68 +11420,80 @@ inline ::dht::HandshakeError HandshakeResponse::error() const { } inline void HandshakeResponse::set_error(::dht::HandshakeError value) { _internal_set_error(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:dht.HandshakeResponse.error) } inline ::dht::HandshakeError HandshakeResponse::_internal_error() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::HandshakeError>(_impl_.error_); } inline void HandshakeResponse::_internal_set_error(::dht::HandshakeError value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = value; } // string version = 3; inline void HandshakeResponse::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HandshakeResponse::version() const +inline const ::std::string& HandshakeResponse::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.HandshakeResponse.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void HandshakeResponse::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HandshakeResponse::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.HandshakeResponse.version) } -inline std::string* HandshakeResponse::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL HandshakeResponse::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:dht.HandshakeResponse.version) return _s; } -inline const std::string& HandshakeResponse::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HandshakeResponse::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void HandshakeResponse::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HandshakeResponse::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* HandshakeResponse::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HandshakeResponse::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* HandshakeResponse::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HandshakeResponse::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeResponse.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void HandshakeResponse::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeResponse::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.HandshakeResponse.version) } @@ -10973,70 +11503,83 @@ inline void HandshakeResponse::set_allocated_version(std::string* value) { // string messageId = 1; inline void Message::clear_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.messageid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& Message::messageid() const +inline const ::std::string& Message::messageid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.messageId) return _internal_messageid(); } template -inline PROTOBUF_ALWAYS_INLINE void Message::set_messageid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void Message::set_messageid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.messageid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.Message.messageId) } -inline std::string* Message::mutable_messageid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_messageid(); +inline ::std::string* PROTOBUF_NONNULL Message::mutable_messageid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_messageid(); // @@protoc_insertion_point(field_mutable:dht.Message.messageId) return _s; } -inline const std::string& Message::_internal_messageid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& Message::_internal_messageid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.messageid_.Get(); } -inline void Message::_internal_set_messageid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void Message::_internal_set_messageid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.messageid_.Set(value, GetArena()); } -inline std::string* Message::_internal_mutable_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL Message::_internal_mutable_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.messageid_.Mutable( GetArena()); } -inline std::string* Message::release_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE Message::release_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.messageId) - return _impl_.messageid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.messageid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.messageid_.Set("", GetArena()); + } + return released; } -inline void Message::set_allocated_messageid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::set_allocated_messageid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.messageid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messageid_.IsDefault()) { - _impl_.messageid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.messageid_.IsDefault()) { + _impl_.messageid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.Message.messageId) } // .dht.PeerDescriptor sourceDescriptor = 2; inline bool Message::has_sourcedescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.sourcedescriptor_ != nullptr); return value; } inline void Message::clear_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcedescriptor_ != nullptr) _impl_.sourcedescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::dht::PeerDescriptor& Message::_internal_sourcedescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcedescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -11044,76 +11587,78 @@ inline const ::dht::PeerDescriptor& Message::sourcedescriptor() const ABSL_ATTRI // @@protoc_insertion_point(field_get:dht.Message.sourceDescriptor) return _internal_sourcedescriptor(); } -inline void Message::unsafe_arena_set_allocated_sourcedescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::unsafe_arena_set_allocated_sourcedescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcedescriptor_); } _impl_.sourcedescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.sourceDescriptor) } -inline ::dht::PeerDescriptor* Message::release_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::release_sourcedescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* released = _impl_.sourcedescriptor_; _impl_.sourcedescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* Message::unsafe_arena_release_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::unsafe_arena_release_sourcedescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.sourceDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* temp = _impl_.sourcedescriptor_; _impl_.sourcedescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* Message::_internal_mutable_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::_internal_mutable_sourcedescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcedescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcedescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcedescriptor_; } -inline ::dht::PeerDescriptor* Message::mutable_sourcedescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::mutable_sourcedescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcedescriptor(); // @@protoc_insertion_point(field_mutable:dht.Message.sourceDescriptor) return _msg; } -inline void Message::set_allocated_sourcedescriptor(::dht::PeerDescriptor* value) { +inline void Message::set_allocated_sourcedescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcedescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcedescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.sourcedescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -11122,17 +11667,18 @@ inline void Message::set_allocated_sourcedescriptor(::dht::PeerDescriptor* value // .dht.PeerDescriptor targetDescriptor = 3; inline bool Message::has_targetdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.targetdescriptor_ != nullptr); return value; } inline void Message::clear_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetdescriptor_ != nullptr) _impl_.targetdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::dht::PeerDescriptor& Message::_internal_targetdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.targetdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -11140,76 +11686,78 @@ inline const ::dht::PeerDescriptor& Message::targetdescriptor() const ABSL_ATTRI // @@protoc_insertion_point(field_get:dht.Message.targetDescriptor) return _internal_targetdescriptor(); } -inline void Message::unsafe_arena_set_allocated_targetdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::unsafe_arena_set_allocated_targetdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetdescriptor_); } _impl_.targetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.targetDescriptor) } -inline ::dht::PeerDescriptor* Message::release_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::release_targetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::PeerDescriptor* released = _impl_.targetdescriptor_; _impl_.targetdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* Message::unsafe_arena_release_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::unsafe_arena_release_targetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.targetDescriptor) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::PeerDescriptor* temp = _impl_.targetdescriptor_; _impl_.targetdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* Message::_internal_mutable_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::_internal_mutable_targetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.targetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.targetdescriptor_; } -inline ::dht::PeerDescriptor* Message::mutable_targetdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::mutable_targetdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::PeerDescriptor* _msg = _internal_mutable_targetdescriptor(); // @@protoc_insertion_point(field_mutable:dht.Message.targetDescriptor) return _msg; } -inline void Message::set_allocated_targetdescriptor(::dht::PeerDescriptor* value) { +inline void Message::set_allocated_targetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.targetdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.targetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -11218,54 +11766,66 @@ inline void Message::set_allocated_targetdescriptor(::dht::PeerDescriptor* value // string serviceId = 4; inline void Message::clear_serviceid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.serviceid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& Message::serviceid() const +inline const ::std::string& Message::serviceid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.serviceId) return _internal_serviceid(); } template -inline PROTOBUF_ALWAYS_INLINE void Message::set_serviceid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void Message::set_serviceid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.serviceid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.Message.serviceId) } -inline std::string* Message::mutable_serviceid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_serviceid(); +inline ::std::string* PROTOBUF_NONNULL Message::mutable_serviceid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_serviceid(); // @@protoc_insertion_point(field_mutable:dht.Message.serviceId) return _s; } -inline const std::string& Message::_internal_serviceid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& Message::_internal_serviceid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.serviceid_.Get(); } -inline void Message::_internal_set_serviceid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void Message::_internal_set_serviceid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.serviceid_.Set(value, GetArena()); } -inline std::string* Message::_internal_mutable_serviceid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL Message::_internal_mutable_serviceid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.serviceid_.Mutable( GetArena()); } -inline std::string* Message::release_serviceid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE Message::release_serviceid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.serviceId) - return _impl_.serviceid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.serviceid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.serviceid_.Set("", GetArena()); + } + return released; } -inline void Message::set_allocated_serviceid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::set_allocated_serviceid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.serviceid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.serviceid_.IsDefault()) { - _impl_.serviceid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.serviceid_.IsDefault()) { + _impl_.serviceid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.Message.serviceId) } @@ -11279,11 +11839,11 @@ inline bool Message::_internal_has_rpcmessage() const { inline void Message::set_has_rpcmessage() { _impl_._oneof_case_[0] = kRpcMessage; } -inline ::protorpc::RpcMessage* Message::release_rpcmessage() { +inline ::protorpc::RpcMessage* PROTOBUF_NULLABLE Message::release_rpcmessage() { // @@protoc_insertion_point(field_release:dht.Message.rpcMessage) if (body_case() == kRpcMessage) { clear_has_body(); - auto* temp = _impl_.body_.rpcmessage_; + auto* temp = reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11294,43 +11854,47 @@ inline ::protorpc::RpcMessage* Message::release_rpcmessage() { } } inline const ::protorpc::RpcMessage& Message::_internal_rpcmessage() const { - return body_case() == kRpcMessage ? *_impl_.body_.rpcmessage_ : reinterpret_cast<::protorpc::RpcMessage&>(::protorpc::_RpcMessage_default_instance_); + return body_case() == kRpcMessage ? static_cast(*reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_)) + : reinterpret_cast(::protorpc::_RpcMessage_default_instance_); } inline const ::protorpc::RpcMessage& Message::rpcmessage() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.rpcMessage) return _internal_rpcmessage(); } -inline ::protorpc::RpcMessage* Message::unsafe_arena_release_rpcmessage() { +inline ::protorpc::RpcMessage* PROTOBUF_NULLABLE Message::unsafe_arena_release_rpcmessage() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.rpcMessage) if (body_case() == kRpcMessage) { clear_has_body(); - auto* temp = _impl_.body_.rpcmessage_; + auto* temp = reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_); _impl_.body_.rpcmessage_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_rpcmessage(::protorpc::RpcMessage* value) { +inline void Message::unsafe_arena_set_allocated_rpcmessage( + ::protorpc::RpcMessage* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_rpcmessage(); - _impl_.body_.rpcmessage_ = value; + _impl_.body_.rpcmessage_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.rpcMessage) } -inline ::protorpc::RpcMessage* Message::_internal_mutable_rpcmessage() { +inline ::protorpc::RpcMessage* PROTOBUF_NONNULL Message::_internal_mutable_rpcmessage() { if (body_case() != kRpcMessage) { clear_body(); set_has_rpcmessage(); - _impl_.body_.rpcmessage_ = CreateMaybeMessage<::protorpc::RpcMessage>(GetArena()); + _impl_.body_.rpcmessage_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::protorpc::RpcMessage>(GetArena())); } - return _impl_.body_.rpcmessage_; + return reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_); } -inline ::protorpc::RpcMessage* Message::mutable_rpcmessage() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::protorpc::RpcMessage* PROTOBUF_NONNULL Message::mutable_rpcmessage() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::protorpc::RpcMessage* _msg = _internal_mutable_rpcmessage(); // @@protoc_insertion_point(field_mutable:dht.Message.rpcMessage) return _msg; @@ -11347,19 +11911,21 @@ inline void Message::set_has_connectivityrequest() { _impl_._oneof_case_[0] = kConnectivityRequest; } inline void Message::clear_connectivityrequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kConnectivityRequest) { if (GetArena() == nullptr) { delete _impl_.body_.connectivityrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityrequest_); } clear_has_body(); } } -inline ::dht::ConnectivityRequest* Message::release_connectivityrequest() { +inline ::dht::ConnectivityRequest* PROTOBUF_NULLABLE Message::release_connectivityrequest() { // @@protoc_insertion_point(field_release:dht.Message.connectivityRequest) if (body_case() == kConnectivityRequest) { clear_has_body(); - auto* temp = _impl_.body_.connectivityrequest_; + auto* temp = reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11370,43 +11936,47 @@ inline ::dht::ConnectivityRequest* Message::release_connectivityrequest() { } } inline const ::dht::ConnectivityRequest& Message::_internal_connectivityrequest() const { - return body_case() == kConnectivityRequest ? *_impl_.body_.connectivityrequest_ : reinterpret_cast<::dht::ConnectivityRequest&>(::dht::_ConnectivityRequest_default_instance_); + return body_case() == kConnectivityRequest ? static_cast(*reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_)) + : reinterpret_cast(::dht::_ConnectivityRequest_default_instance_); } inline const ::dht::ConnectivityRequest& Message::connectivityrequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.connectivityRequest) return _internal_connectivityrequest(); } -inline ::dht::ConnectivityRequest* Message::unsafe_arena_release_connectivityrequest() { +inline ::dht::ConnectivityRequest* PROTOBUF_NULLABLE Message::unsafe_arena_release_connectivityrequest() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.connectivityRequest) if (body_case() == kConnectivityRequest) { clear_has_body(); - auto* temp = _impl_.body_.connectivityrequest_; + auto* temp = reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_); _impl_.body_.connectivityrequest_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_connectivityrequest(::dht::ConnectivityRequest* value) { +inline void Message::unsafe_arena_set_allocated_connectivityrequest( + ::dht::ConnectivityRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_connectivityrequest(); - _impl_.body_.connectivityrequest_ = value; + _impl_.body_.connectivityrequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.connectivityRequest) } -inline ::dht::ConnectivityRequest* Message::_internal_mutable_connectivityrequest() { +inline ::dht::ConnectivityRequest* PROTOBUF_NONNULL Message::_internal_mutable_connectivityrequest() { if (body_case() != kConnectivityRequest) { clear_body(); set_has_connectivityrequest(); - _impl_.body_.connectivityrequest_ = CreateMaybeMessage<::dht::ConnectivityRequest>(GetArena()); + _impl_.body_.connectivityrequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityRequest>(GetArena())); } - return _impl_.body_.connectivityrequest_; + return reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_); } -inline ::dht::ConnectivityRequest* Message::mutable_connectivityrequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityRequest* PROTOBUF_NONNULL Message::mutable_connectivityrequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::ConnectivityRequest* _msg = _internal_mutable_connectivityrequest(); // @@protoc_insertion_point(field_mutable:dht.Message.connectivityRequest) return _msg; @@ -11423,19 +11993,21 @@ inline void Message::set_has_connectivityresponse() { _impl_._oneof_case_[0] = kConnectivityResponse; } inline void Message::clear_connectivityresponse() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kConnectivityResponse) { if (GetArena() == nullptr) { delete _impl_.body_.connectivityresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityresponse_); } clear_has_body(); } } -inline ::dht::ConnectivityResponse* Message::release_connectivityresponse() { +inline ::dht::ConnectivityResponse* PROTOBUF_NULLABLE Message::release_connectivityresponse() { // @@protoc_insertion_point(field_release:dht.Message.connectivityResponse) if (body_case() == kConnectivityResponse) { clear_has_body(); - auto* temp = _impl_.body_.connectivityresponse_; + auto* temp = reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11446,43 +12018,47 @@ inline ::dht::ConnectivityResponse* Message::release_connectivityresponse() { } } inline const ::dht::ConnectivityResponse& Message::_internal_connectivityresponse() const { - return body_case() == kConnectivityResponse ? *_impl_.body_.connectivityresponse_ : reinterpret_cast<::dht::ConnectivityResponse&>(::dht::_ConnectivityResponse_default_instance_); + return body_case() == kConnectivityResponse ? static_cast(*reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_)) + : reinterpret_cast(::dht::_ConnectivityResponse_default_instance_); } inline const ::dht::ConnectivityResponse& Message::connectivityresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.connectivityResponse) return _internal_connectivityresponse(); } -inline ::dht::ConnectivityResponse* Message::unsafe_arena_release_connectivityresponse() { +inline ::dht::ConnectivityResponse* PROTOBUF_NULLABLE Message::unsafe_arena_release_connectivityresponse() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.connectivityResponse) if (body_case() == kConnectivityResponse) { clear_has_body(); - auto* temp = _impl_.body_.connectivityresponse_; + auto* temp = reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_); _impl_.body_.connectivityresponse_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_connectivityresponse(::dht::ConnectivityResponse* value) { +inline void Message::unsafe_arena_set_allocated_connectivityresponse( + ::dht::ConnectivityResponse* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_connectivityresponse(); - _impl_.body_.connectivityresponse_ = value; + _impl_.body_.connectivityresponse_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.connectivityResponse) } -inline ::dht::ConnectivityResponse* Message::_internal_mutable_connectivityresponse() { +inline ::dht::ConnectivityResponse* PROTOBUF_NONNULL Message::_internal_mutable_connectivityresponse() { if (body_case() != kConnectivityResponse) { clear_body(); set_has_connectivityresponse(); - _impl_.body_.connectivityresponse_ = CreateMaybeMessage<::dht::ConnectivityResponse>(GetArena()); + _impl_.body_.connectivityresponse_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityResponse>(GetArena())); } - return _impl_.body_.connectivityresponse_; + return reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_); } -inline ::dht::ConnectivityResponse* Message::mutable_connectivityresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityResponse* PROTOBUF_NONNULL Message::mutable_connectivityresponse() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::ConnectivityResponse* _msg = _internal_mutable_connectivityresponse(); // @@protoc_insertion_point(field_mutable:dht.Message.connectivityResponse) return _msg; @@ -11499,19 +12075,21 @@ inline void Message::set_has_handshakerequest() { _impl_._oneof_case_[0] = kHandshakeRequest; } inline void Message::clear_handshakerequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kHandshakeRequest) { if (GetArena() == nullptr) { delete _impl_.body_.handshakerequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakerequest_); } clear_has_body(); } } -inline ::dht::HandshakeRequest* Message::release_handshakerequest() { +inline ::dht::HandshakeRequest* PROTOBUF_NULLABLE Message::release_handshakerequest() { // @@protoc_insertion_point(field_release:dht.Message.handshakeRequest) if (body_case() == kHandshakeRequest) { clear_has_body(); - auto* temp = _impl_.body_.handshakerequest_; + auto* temp = reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11522,43 +12100,47 @@ inline ::dht::HandshakeRequest* Message::release_handshakerequest() { } } inline const ::dht::HandshakeRequest& Message::_internal_handshakerequest() const { - return body_case() == kHandshakeRequest ? *_impl_.body_.handshakerequest_ : reinterpret_cast<::dht::HandshakeRequest&>(::dht::_HandshakeRequest_default_instance_); + return body_case() == kHandshakeRequest ? static_cast(*reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_)) + : reinterpret_cast(::dht::_HandshakeRequest_default_instance_); } inline const ::dht::HandshakeRequest& Message::handshakerequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.handshakeRequest) return _internal_handshakerequest(); } -inline ::dht::HandshakeRequest* Message::unsafe_arena_release_handshakerequest() { +inline ::dht::HandshakeRequest* PROTOBUF_NULLABLE Message::unsafe_arena_release_handshakerequest() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.handshakeRequest) if (body_case() == kHandshakeRequest) { clear_has_body(); - auto* temp = _impl_.body_.handshakerequest_; + auto* temp = reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_); _impl_.body_.handshakerequest_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_handshakerequest(::dht::HandshakeRequest* value) { +inline void Message::unsafe_arena_set_allocated_handshakerequest( + ::dht::HandshakeRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_handshakerequest(); - _impl_.body_.handshakerequest_ = value; + _impl_.body_.handshakerequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.handshakeRequest) } -inline ::dht::HandshakeRequest* Message::_internal_mutable_handshakerequest() { +inline ::dht::HandshakeRequest* PROTOBUF_NONNULL Message::_internal_mutable_handshakerequest() { if (body_case() != kHandshakeRequest) { clear_body(); set_has_handshakerequest(); - _impl_.body_.handshakerequest_ = CreateMaybeMessage<::dht::HandshakeRequest>(GetArena()); + _impl_.body_.handshakerequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::HandshakeRequest>(GetArena())); } - return _impl_.body_.handshakerequest_; + return reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_); } -inline ::dht::HandshakeRequest* Message::mutable_handshakerequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::HandshakeRequest* PROTOBUF_NONNULL Message::mutable_handshakerequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::HandshakeRequest* _msg = _internal_mutable_handshakerequest(); // @@protoc_insertion_point(field_mutable:dht.Message.handshakeRequest) return _msg; @@ -11575,19 +12157,21 @@ inline void Message::set_has_handshakeresponse() { _impl_._oneof_case_[0] = kHandshakeResponse; } inline void Message::clear_handshakeresponse() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kHandshakeResponse) { if (GetArena() == nullptr) { delete _impl_.body_.handshakeresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakeresponse_); } clear_has_body(); } } -inline ::dht::HandshakeResponse* Message::release_handshakeresponse() { +inline ::dht::HandshakeResponse* PROTOBUF_NULLABLE Message::release_handshakeresponse() { // @@protoc_insertion_point(field_release:dht.Message.handshakeResponse) if (body_case() == kHandshakeResponse) { clear_has_body(); - auto* temp = _impl_.body_.handshakeresponse_; + auto* temp = reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11598,43 +12182,47 @@ inline ::dht::HandshakeResponse* Message::release_handshakeresponse() { } } inline const ::dht::HandshakeResponse& Message::_internal_handshakeresponse() const { - return body_case() == kHandshakeResponse ? *_impl_.body_.handshakeresponse_ : reinterpret_cast<::dht::HandshakeResponse&>(::dht::_HandshakeResponse_default_instance_); + return body_case() == kHandshakeResponse ? static_cast(*reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_)) + : reinterpret_cast(::dht::_HandshakeResponse_default_instance_); } inline const ::dht::HandshakeResponse& Message::handshakeresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.handshakeResponse) return _internal_handshakeresponse(); } -inline ::dht::HandshakeResponse* Message::unsafe_arena_release_handshakeresponse() { +inline ::dht::HandshakeResponse* PROTOBUF_NULLABLE Message::unsafe_arena_release_handshakeresponse() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.handshakeResponse) if (body_case() == kHandshakeResponse) { clear_has_body(); - auto* temp = _impl_.body_.handshakeresponse_; + auto* temp = reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_); _impl_.body_.handshakeresponse_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_handshakeresponse(::dht::HandshakeResponse* value) { +inline void Message::unsafe_arena_set_allocated_handshakeresponse( + ::dht::HandshakeResponse* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_handshakeresponse(); - _impl_.body_.handshakeresponse_ = value; + _impl_.body_.handshakeresponse_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.handshakeResponse) } -inline ::dht::HandshakeResponse* Message::_internal_mutable_handshakeresponse() { +inline ::dht::HandshakeResponse* PROTOBUF_NONNULL Message::_internal_mutable_handshakeresponse() { if (body_case() != kHandshakeResponse) { clear_body(); set_has_handshakeresponse(); - _impl_.body_.handshakeresponse_ = CreateMaybeMessage<::dht::HandshakeResponse>(GetArena()); + _impl_.body_.handshakeresponse_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::HandshakeResponse>(GetArena())); } - return _impl_.body_.handshakeresponse_; + return reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_); } -inline ::dht::HandshakeResponse* Message::mutable_handshakeresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::HandshakeResponse* PROTOBUF_NONNULL Message::mutable_handshakeresponse() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::HandshakeResponse* _msg = _internal_mutable_handshakeresponse(); // @@protoc_insertion_point(field_mutable:dht.Message.handshakeResponse) return _msg; @@ -11651,19 +12239,21 @@ inline void Message::set_has_recursiveoperationrequest() { _impl_._oneof_case_[0] = kRecursiveOperationRequest; } inline void Message::clear_recursiveoperationrequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kRecursiveOperationRequest) { if (GetArena() == nullptr) { delete _impl_.body_.recursiveoperationrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.recursiveoperationrequest_); } clear_has_body(); } } -inline ::dht::RecursiveOperationRequest* Message::release_recursiveoperationrequest() { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE Message::release_recursiveoperationrequest() { // @@protoc_insertion_point(field_release:dht.Message.recursiveOperationRequest) if (body_case() == kRecursiveOperationRequest) { clear_has_body(); - auto* temp = _impl_.body_.recursiveoperationrequest_; + auto* temp = reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11674,43 +12264,47 @@ inline ::dht::RecursiveOperationRequest* Message::release_recursiveoperationrequ } } inline const ::dht::RecursiveOperationRequest& Message::_internal_recursiveoperationrequest() const { - return body_case() == kRecursiveOperationRequest ? *_impl_.body_.recursiveoperationrequest_ : reinterpret_cast<::dht::RecursiveOperationRequest&>(::dht::_RecursiveOperationRequest_default_instance_); + return body_case() == kRecursiveOperationRequest ? static_cast(*reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_)) + : reinterpret_cast(::dht::_RecursiveOperationRequest_default_instance_); } inline const ::dht::RecursiveOperationRequest& Message::recursiveoperationrequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.recursiveOperationRequest) return _internal_recursiveoperationrequest(); } -inline ::dht::RecursiveOperationRequest* Message::unsafe_arena_release_recursiveoperationrequest() { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE Message::unsafe_arena_release_recursiveoperationrequest() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.recursiveOperationRequest) if (body_case() == kRecursiveOperationRequest) { clear_has_body(); - auto* temp = _impl_.body_.recursiveoperationrequest_; + auto* temp = reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_); _impl_.body_.recursiveoperationrequest_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* value) { +inline void Message::unsafe_arena_set_allocated_recursiveoperationrequest( + ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_recursiveoperationrequest(); - _impl_.body_.recursiveoperationrequest_ = value; + _impl_.body_.recursiveoperationrequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.recursiveOperationRequest) } -inline ::dht::RecursiveOperationRequest* Message::_internal_mutable_recursiveoperationrequest() { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL Message::_internal_mutable_recursiveoperationrequest() { if (body_case() != kRecursiveOperationRequest) { clear_body(); set_has_recursiveoperationrequest(); - _impl_.body_.recursiveoperationrequest_ = CreateMaybeMessage<::dht::RecursiveOperationRequest>(GetArena()); + _impl_.body_.recursiveoperationrequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::RecursiveOperationRequest>(GetArena())); } - return _impl_.body_.recursiveoperationrequest_; + return reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_); } -inline ::dht::RecursiveOperationRequest* Message::mutable_recursiveoperationrequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL Message::mutable_recursiveoperationrequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::RecursiveOperationRequest* _msg = _internal_mutable_recursiveoperationrequest(); // @@protoc_insertion_point(field_mutable:dht.Message.recursiveOperationRequest) return _msg; @@ -11739,107 +12333,131 @@ inline Message::BodyCase Message::body_case() const { // string description = 1; inline void RtcOffer::clear_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RtcOffer::description() const +inline const ::std::string& RtcOffer::description() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcOffer.description) return _internal_description(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcOffer::set_description(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcOffer::set_description(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.description_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcOffer.description) } -inline std::string* RtcOffer::mutable_description() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_description(); +inline ::std::string* PROTOBUF_NONNULL RtcOffer::mutable_description() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:dht.RtcOffer.description) return _s; } -inline const std::string& RtcOffer::_internal_description() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcOffer::_internal_description() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.description_.Get(); } -inline void RtcOffer::_internal_set_description(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcOffer::_internal_set_description(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.Set(value, GetArena()); } -inline std::string* RtcOffer::_internal_mutable_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcOffer::_internal_mutable_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.description_.Mutable( GetArena()); } -inline std::string* RtcOffer::release_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcOffer::release_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcOffer.description) - return _impl_.description_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.description_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.description_.Set("", GetArena()); + } + return released; } -inline void RtcOffer::set_allocated_description(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcOffer::set_allocated_description(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.description_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcOffer.description) } // string connectionId = 2; inline void RtcOffer::clear_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RtcOffer::connectionid() const +inline const ::std::string& RtcOffer::connectionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcOffer.connectionId) return _internal_connectionid(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcOffer::set_connectionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcOffer::set_connectionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.connectionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcOffer.connectionId) } -inline std::string* RtcOffer::mutable_connectionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_connectionid(); +inline ::std::string* PROTOBUF_NONNULL RtcOffer::mutable_connectionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_connectionid(); // @@protoc_insertion_point(field_mutable:dht.RtcOffer.connectionId) return _s; } -inline const std::string& RtcOffer::_internal_connectionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcOffer::_internal_connectionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connectionid_.Get(); } -inline void RtcOffer::_internal_set_connectionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcOffer::_internal_set_connectionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.Set(value, GetArena()); } -inline std::string* RtcOffer::_internal_mutable_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcOffer::_internal_mutable_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.connectionid_.Mutable( GetArena()); } -inline std::string* RtcOffer::release_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcOffer::release_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcOffer.connectionId) - return _impl_.connectionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.connectionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.connectionid_.Set("", GetArena()); + } + return released; } -inline void RtcOffer::set_allocated_connectionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcOffer::set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.connectionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.connectionid_.IsDefault()) { - _impl_.connectionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.connectionid_.IsDefault()) { + _impl_.connectionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcOffer.connectionId) } @@ -11849,107 +12467,131 @@ inline void RtcOffer::set_allocated_connectionid(std::string* value) { // string description = 1; inline void RtcAnswer::clear_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RtcAnswer::description() const +inline const ::std::string& RtcAnswer::description() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcAnswer.description) return _internal_description(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_description(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_description(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.description_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcAnswer.description) } -inline std::string* RtcAnswer::mutable_description() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_description(); +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::mutable_description() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:dht.RtcAnswer.description) return _s; } -inline const std::string& RtcAnswer::_internal_description() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcAnswer::_internal_description() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.description_.Get(); } -inline void RtcAnswer::_internal_set_description(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcAnswer::_internal_set_description(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.Set(value, GetArena()); } -inline std::string* RtcAnswer::_internal_mutable_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::_internal_mutable_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.description_.Mutable( GetArena()); } -inline std::string* RtcAnswer::release_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcAnswer::release_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcAnswer.description) - return _impl_.description_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.description_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.description_.Set("", GetArena()); + } + return released; } -inline void RtcAnswer::set_allocated_description(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcAnswer::set_allocated_description(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.description_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcAnswer.description) } // string connectionId = 2; inline void RtcAnswer::clear_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RtcAnswer::connectionid() const +inline const ::std::string& RtcAnswer::connectionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcAnswer.connectionId) return _internal_connectionid(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_connectionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_connectionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.connectionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcAnswer.connectionId) } -inline std::string* RtcAnswer::mutable_connectionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_connectionid(); +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::mutable_connectionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_connectionid(); // @@protoc_insertion_point(field_mutable:dht.RtcAnswer.connectionId) return _s; } -inline const std::string& RtcAnswer::_internal_connectionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcAnswer::_internal_connectionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connectionid_.Get(); } -inline void RtcAnswer::_internal_set_connectionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcAnswer::_internal_set_connectionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.Set(value, GetArena()); } -inline std::string* RtcAnswer::_internal_mutable_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::_internal_mutable_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.connectionid_.Mutable( GetArena()); } -inline std::string* RtcAnswer::release_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcAnswer::release_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcAnswer.connectionId) - return _impl_.connectionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.connectionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.connectionid_.Set("", GetArena()); + } + return released; } -inline void RtcAnswer::set_allocated_connectionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcAnswer::set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.connectionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.connectionid_.IsDefault()) { - _impl_.connectionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.connectionid_.IsDefault()) { + _impl_.connectionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcAnswer.connectionId) } @@ -11959,160 +12601,196 @@ inline void RtcAnswer::set_allocated_connectionid(std::string* value) { // string candidate = 1; inline void IceCandidate::clear_candidate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.candidate_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& IceCandidate::candidate() const +inline const ::std::string& IceCandidate::candidate() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.IceCandidate.candidate) return _internal_candidate(); } template -inline PROTOBUF_ALWAYS_INLINE void IceCandidate::set_candidate(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void IceCandidate::set_candidate(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.candidate_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.IceCandidate.candidate) } -inline std::string* IceCandidate::mutable_candidate() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_candidate(); +inline ::std::string* PROTOBUF_NONNULL IceCandidate::mutable_candidate() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_candidate(); // @@protoc_insertion_point(field_mutable:dht.IceCandidate.candidate) return _s; } -inline const std::string& IceCandidate::_internal_candidate() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& IceCandidate::_internal_candidate() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.candidate_.Get(); } -inline void IceCandidate::_internal_set_candidate(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void IceCandidate::_internal_set_candidate(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.candidate_.Set(value, GetArena()); } -inline std::string* IceCandidate::_internal_mutable_candidate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL IceCandidate::_internal_mutable_candidate() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.candidate_.Mutable( GetArena()); } -inline std::string* IceCandidate::release_candidate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE IceCandidate::release_candidate() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.IceCandidate.candidate) - return _impl_.candidate_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.candidate_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.candidate_.Set("", GetArena()); + } + return released; } -inline void IceCandidate::set_allocated_candidate(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void IceCandidate::set_allocated_candidate(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.candidate_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.candidate_.IsDefault()) { - _impl_.candidate_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.candidate_.IsDefault()) { + _impl_.candidate_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.IceCandidate.candidate) } // string mid = 2; inline void IceCandidate::clear_mid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& IceCandidate::mid() const +inline const ::std::string& IceCandidate::mid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.IceCandidate.mid) return _internal_mid(); } template -inline PROTOBUF_ALWAYS_INLINE void IceCandidate::set_mid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void IceCandidate::set_mid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.mid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.IceCandidate.mid) } -inline std::string* IceCandidate::mutable_mid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_mid(); +inline ::std::string* PROTOBUF_NONNULL IceCandidate::mutable_mid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_mid(); // @@protoc_insertion_point(field_mutable:dht.IceCandidate.mid) return _s; } -inline const std::string& IceCandidate::_internal_mid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& IceCandidate::_internal_mid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.mid_.Get(); } -inline void IceCandidate::_internal_set_mid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void IceCandidate::_internal_set_mid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mid_.Set(value, GetArena()); } -inline std::string* IceCandidate::_internal_mutable_mid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL IceCandidate::_internal_mutable_mid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.mid_.Mutable( GetArena()); } -inline std::string* IceCandidate::release_mid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE IceCandidate::release_mid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.IceCandidate.mid) - return _impl_.mid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.mid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.mid_.Set("", GetArena()); + } + return released; } -inline void IceCandidate::set_allocated_mid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void IceCandidate::set_allocated_mid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.mid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mid_.IsDefault()) { - _impl_.mid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.mid_.IsDefault()) { + _impl_.mid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.IceCandidate.mid) } // string connectionId = 3; inline void IceCandidate::clear_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& IceCandidate::connectionid() const +inline const ::std::string& IceCandidate::connectionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.IceCandidate.connectionId) return _internal_connectionid(); } template -inline PROTOBUF_ALWAYS_INLINE void IceCandidate::set_connectionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void IceCandidate::set_connectionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.connectionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.IceCandidate.connectionId) } -inline std::string* IceCandidate::mutable_connectionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_connectionid(); +inline ::std::string* PROTOBUF_NONNULL IceCandidate::mutable_connectionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_connectionid(); // @@protoc_insertion_point(field_mutable:dht.IceCandidate.connectionId) return _s; } -inline const std::string& IceCandidate::_internal_connectionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& IceCandidate::_internal_connectionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connectionid_.Get(); } -inline void IceCandidate::_internal_set_connectionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void IceCandidate::_internal_set_connectionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.Set(value, GetArena()); } -inline std::string* IceCandidate::_internal_mutable_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL IceCandidate::_internal_mutable_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.connectionid_.Mutable( GetArena()); } -inline std::string* IceCandidate::release_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE IceCandidate::release_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.IceCandidate.connectionId) - return _impl_.connectionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.connectionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.connectionid_.Set("", GetArena()); + } + return released; } -inline void IceCandidate::set_allocated_connectionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void IceCandidate::set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.connectionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.connectionid_.IsDefault()) { - _impl_.connectionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.connectionid_.IsDefault()) { + _impl_.connectionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.IceCandidate.connectionId) } @@ -12122,54 +12800,66 @@ inline void IceCandidate::set_allocated_connectionid(std::string* value) { // string lockId = 1; inline void LockRequest::clear_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& LockRequest::lockid() const +inline const ::std::string& LockRequest::lockid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.LockRequest.lockId) return _internal_lockid(); } template -inline PROTOBUF_ALWAYS_INLINE void LockRequest::set_lockid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void LockRequest::set_lockid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.lockid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.LockRequest.lockId) } -inline std::string* LockRequest::mutable_lockid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_lockid(); +inline ::std::string* PROTOBUF_NONNULL LockRequest::mutable_lockid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_lockid(); // @@protoc_insertion_point(field_mutable:dht.LockRequest.lockId) return _s; } -inline const std::string& LockRequest::_internal_lockid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& LockRequest::_internal_lockid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.lockid_.Get(); } -inline void LockRequest::_internal_set_lockid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void LockRequest::_internal_set_lockid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.Set(value, GetArena()); } -inline std::string* LockRequest::_internal_mutable_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL LockRequest::_internal_mutable_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.lockid_.Mutable( GetArena()); } -inline std::string* LockRequest::release_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE LockRequest::release_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.LockRequest.lockId) - return _impl_.lockid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.lockid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.lockid_.Set("", GetArena()); + } + return released; } -inline void LockRequest::set_allocated_lockid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void LockRequest::set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.lockid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lockid_.IsDefault()) { - _impl_.lockid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lockid_.IsDefault()) { + _impl_.lockid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.LockRequest.lockId) } @@ -12179,54 +12869,66 @@ inline void LockRequest::set_allocated_lockid(std::string* value) { // string lockId = 1; inline void UnlockRequest::clear_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& UnlockRequest::lockid() const +inline const ::std::string& UnlockRequest::lockid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.UnlockRequest.lockId) return _internal_lockid(); } template -inline PROTOBUF_ALWAYS_INLINE void UnlockRequest::set_lockid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void UnlockRequest::set_lockid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.lockid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.UnlockRequest.lockId) } -inline std::string* UnlockRequest::mutable_lockid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_lockid(); +inline ::std::string* PROTOBUF_NONNULL UnlockRequest::mutable_lockid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_lockid(); // @@protoc_insertion_point(field_mutable:dht.UnlockRequest.lockId) return _s; } -inline const std::string& UnlockRequest::_internal_lockid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& UnlockRequest::_internal_lockid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.lockid_.Get(); } -inline void UnlockRequest::_internal_set_lockid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void UnlockRequest::_internal_set_lockid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.Set(value, GetArena()); } -inline std::string* UnlockRequest::_internal_mutable_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL UnlockRequest::_internal_mutable_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.lockid_.Mutable( GetArena()); } -inline std::string* UnlockRequest::release_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE UnlockRequest::release_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.UnlockRequest.lockId) - return _impl_.lockid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.lockid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.lockid_.Set("", GetArena()); + } + return released; } -inline void UnlockRequest::set_allocated_lockid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void UnlockRequest::set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.lockid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lockid_.IsDefault()) { - _impl_.lockid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lockid_.IsDefault()) { + _impl_.lockid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.UnlockRequest.lockId) } @@ -12236,8 +12938,10 @@ inline void UnlockRequest::set_allocated_lockid(std::string* value) { // bool accepted = 1; inline void LockResponse::clear_accepted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline bool LockResponse::accepted() const { // @@protoc_insertion_point(field_get:dht.LockResponse.accepted) @@ -12245,15 +12949,15 @@ inline bool LockResponse::accepted() const { } inline void LockResponse::set_accepted(bool value) { _internal_set_accepted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:dht.LockResponse.accepted) } inline bool LockResponse::_internal_accepted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.accepted_; } inline void LockResponse::_internal_set_accepted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = value; } @@ -12263,8 +12967,10 @@ inline void LockResponse::_internal_set_accepted(bool value) { // .dht.DisconnectMode disconnectMode = 1; inline void DisconnectNotice::clear_disconnectmode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.disconnectmode_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline ::dht::DisconnectMode DisconnectNotice::disconnectmode() const { // @@protoc_insertion_point(field_get:dht.DisconnectNotice.disconnectMode) @@ -12272,15 +12978,15 @@ inline ::dht::DisconnectMode DisconnectNotice::disconnectmode() const { } inline void DisconnectNotice::set_disconnectmode(::dht::DisconnectMode value) { _internal_set_disconnectmode(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:dht.DisconnectNotice.disconnectMode) } inline ::dht::DisconnectMode DisconnectNotice::_internal_disconnectmode() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::DisconnectMode>(_impl_.disconnectmode_); } inline void DisconnectNotice::_internal_set_disconnectmode(::dht::DisconnectMode value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.disconnectmode_ = value; } @@ -12290,54 +12996,66 @@ inline void DisconnectNotice::_internal_set_disconnectmode(::dht::DisconnectMode // bytes key = 1; inline void ExternalFetchDataRequest::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ExternalFetchDataRequest::key() const +inline const ::std::string& ExternalFetchDataRequest::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ExternalFetchDataRequest.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void ExternalFetchDataRequest::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ExternalFetchDataRequest::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ExternalFetchDataRequest.key) } -inline std::string* ExternalFetchDataRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL ExternalFetchDataRequest::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.ExternalFetchDataRequest.key) return _s; } -inline const std::string& ExternalFetchDataRequest::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ExternalFetchDataRequest::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void ExternalFetchDataRequest::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ExternalFetchDataRequest::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* ExternalFetchDataRequest::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ExternalFetchDataRequest::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* ExternalFetchDataRequest::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ExternalFetchDataRequest::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ExternalFetchDataRequest.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void ExternalFetchDataRequest::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ExternalFetchDataRequest::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ExternalFetchDataRequest.key) } @@ -12353,18 +13071,21 @@ inline int ExternalFetchDataResponse::entries_size() const { return _internal_entries_size(); } inline void ExternalFetchDataResponse::clear_entries() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.entries_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::DataEntry* ExternalFetchDataResponse::mutable_entries(int index) +inline ::dht::DataEntry* PROTOBUF_NONNULL ExternalFetchDataResponse::mutable_entries(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ExternalFetchDataResponse.entries) return _internal_mutable_entries()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* ExternalFetchDataResponse::mutable_entries() +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL ExternalFetchDataResponse::mutable_entries() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ExternalFetchDataResponse.entries) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_entries(); } inline const ::dht::DataEntry& ExternalFetchDataResponse::entries(int index) const @@ -12372,9 +13093,13 @@ inline const ::dht::DataEntry& ExternalFetchDataResponse::entries(int index) con // @@protoc_insertion_point(field_get:dht.ExternalFetchDataResponse.entries) return _internal_entries().Get(index); } -inline ::dht::DataEntry* ExternalFetchDataResponse::add_entries() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::DataEntry* _add = _internal_mutable_entries()->Add(); +inline ::dht::DataEntry* PROTOBUF_NONNULL ExternalFetchDataResponse::add_entries() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::DataEntry* _add = + _internal_mutable_entries()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ExternalFetchDataResponse.entries) return _add; } @@ -12385,12 +13110,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& ExternalFet } inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& ExternalFetchDataResponse::_internal_entries() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.entries_; } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL ExternalFetchDataResponse::_internal_mutable_entries() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.entries_; } @@ -12408,37 +13133,37 @@ namespace protobuf { template <> struct is_proto_enum<::dht::RecursiveOperation> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::RecursiveOperation>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::RecursiveOperation>() { return ::dht::RecursiveOperation_descriptor(); } template <> struct is_proto_enum<::dht::NodeType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::NodeType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::NodeType>() { return ::dht::NodeType_descriptor(); } template <> struct is_proto_enum<::dht::RpcResponseError> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::RpcResponseError>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::RpcResponseError>() { return ::dht::RpcResponseError_descriptor(); } template <> struct is_proto_enum<::dht::RouteMessageError> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::RouteMessageError>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::RouteMessageError>() { return ::dht::RouteMessageError_descriptor(); } template <> struct is_proto_enum<::dht::HandshakeError> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::HandshakeError>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::HandshakeError>() { return ::dht::HandshakeError_descriptor(); } template <> struct is_proto_enum<::dht::DisconnectMode> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::DisconnectMode>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::DisconnectMode>() { return ::dht::DisconnectMode_descriptor(); } @@ -12449,4 +13174,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::dht::DisconnectMode>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh +#endif // packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh diff --git a/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc b/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc index 842c2e07..b8f9719f 100644 --- a/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc +++ b/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/proto-rpc/protos/ProtoRpc.proto +// Protobuf C++ Version: 6.33.4 #include "packages/proto-rpc/protos/ProtoRpc.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" @@ -18,9 +23,16 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; namespace protorpc { - template -PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : RpcMessage_HeaderEntry_DoNotUse::MapEntry(RpcMessage_HeaderEntry_DoNotUse_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : RpcMessage_HeaderEntry_DoNotUse::MapEntry() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal { PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal() {} @@ -35,7 +47,6 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RpcMessage::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - header_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), @@ -49,11 +60,18 @@ inline constexpr RpcMessage::Impl_::Impl_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), body_{nullptr}, - errortype_{static_cast< ::protorpc::RpcErrorType >(0)} {} + errortype_{static_cast< ::protorpc::RpcErrorType >(0)}, + header_{} {} template PROTOBUF_CONSTEXPR RpcMessage::RpcMessage(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RpcMessage_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RpcMessageDefaultTypeInternal { PROTOBUF_CONSTEXPR RpcMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RpcMessageDefaultTypeInternal() {} @@ -72,7 +90,13 @@ inline constexpr Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( template PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal { PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal() {} @@ -84,71 +108,57 @@ struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal _Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_; } // namespace protorpc -static ::_pb::Metadata file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[3]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = nullptr; -const ::uint32_t TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _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(::protorpc::RpcMessage_HeaderEntry_DoNotUse, key_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, value_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _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(::protorpc::RpcMessage, _impl_.header_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errortype_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorclassname_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorcode_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errormessage_), - ~0u, - 3, - ~0u, - 4, - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _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(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), - 0, +const ::uint32_t + TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_.value_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.header_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errortype_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorclassname_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorcode_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errormessage_), + 6, + 4, + 0, + 5, + 1, + 2, + 3, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 10, -1, sizeof(::protorpc::RpcMessage_HeaderEntry_DoNotUse)}, - {12, 27, -1, sizeof(::protorpc::RpcMessage)}, - {34, 43, -1, sizeof(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::protorpc::RpcMessage_HeaderEntry_DoNotUse)}, + {7, sizeof(::protorpc::RpcMessage)}, + {24, sizeof(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::protorpc::_RpcMessage_HeaderEntry_DoNotUse_default_instance_._instance, &::protorpc::_RpcMessage_default_instance_._instance, &::protorpc::_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_._instance, }; -const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n(packages/proto-rpc/protos/ProtoRpc.pro" "to\022\010protorpc\032\033google/protobuf/empty.prot" "o\032\031google/protobuf/any.proto\"\344\002\n\nRpcMess" @@ -167,13 +177,13 @@ const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_ "UNKNOWN_RPC_METHOD\020\002\022\020\n\014CLIENT_ERROR\020\003\022\020" "\n\014SERVER_ERROR\020\004B\002H\002b\006proto3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_deps[2] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::absl::once_flag descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = { false, false, 668, @@ -186,127 +196,185 @@ const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2 schemas, file_default_instances, TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, file_level_service_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter() { - return &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto); namespace protorpc { -const ::google::protobuf::EnumDescriptor* RpcErrorType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcErrorType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto); return file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t RpcErrorType_internal_data_[] = { 327680u, 0u, }; -bool RpcErrorType_IsValid(int value) { - return 0 <= value && value <= 4; -} // =================================================================== -RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() {} -RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* arena) - : SuperType(arena) {} -::google::protobuf::Metadata RpcMessage_HeaderEntry_DoNotUse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[0]); +#if defined(PROTOBUF_CUSTOM_VTABLE) +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() + : SuperType(RpcMessage_HeaderEntry_DoNotUse_class_data_.base()) {} +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : SuperType(arena, RpcMessage_HeaderEntry_DoNotUse_class_data_.base()) {} +#else // PROTOBUF_CUSTOM_VTABLE +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() : SuperType() {} +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : SuperType(arena) {} +#endif // PROTOBUF_CUSTOM_VTABLE +inline void* PROTOBUF_NONNULL RpcMessage_HeaderEntry_DoNotUse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RpcMessage_HeaderEntry_DoNotUse(arena); +} +constexpr auto RpcMessage_HeaderEntry_DoNotUse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcMessage_HeaderEntry_DoNotUse), + alignof(RpcMessage_HeaderEntry_DoNotUse)); +} +constexpr auto RpcMessage_HeaderEntry_DoNotUse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RpcMessage_HeaderEntry_DoNotUse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcMessage_HeaderEntry_DoNotUse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcMessage_HeaderEntry_DoNotUse::SharedDtor, + static_cast(&RpcMessage_HeaderEntry_DoNotUse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_._cached_size_), + false, + }, + &RpcMessage_HeaderEntry_DoNotUse::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; } + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_ = + RpcMessage_HeaderEntry_DoNotUse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RpcMessage_HeaderEntry_DoNotUse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RpcMessage_HeaderEntry_DoNotUse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RpcMessage_HeaderEntry_DoNotUse_class_data_.tc_table); + return RpcMessage_HeaderEntry_DoNotUse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 48, 2> +RpcMessage_HeaderEntry_DoNotUse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_._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 + RpcMessage_HeaderEntry_DoNotUse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::DiscardEverythingFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::RpcMessage_HeaderEntry_DoNotUse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string value = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.value_)}}, + // string key = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string key = 1; + {PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string value = 2; + {PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.value_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\37\3\5\0\0\0\0\0" + "protorpc.RpcMessage.HeaderEntry" + "key" + "value" + }}, +}; // =================================================================== class RpcMessage::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._has_bits_); - static const ::google::protobuf::Any& body(const RpcMessage* msg); - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_errortype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_errorclassname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_errorcode(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_errormessage(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._has_bits_); }; -const ::google::protobuf::Any& RpcMessage::_Internal::body(const RpcMessage* msg) { - return *msg->_impl_.body_; -} void RpcMessage::clear_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ != nullptr) _impl_.body_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -RpcMessage::RpcMessage(::google::protobuf::Arena* arena) +RpcMessage::RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RpcMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:protorpc.RpcMessage) } -inline PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::protorpc::RpcMessage& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - header_{visibility, arena, from.header_}, requestid_(arena, from.requestid_), errorclassname_(arena, from.errorclassname_), errorcode_(arena, from.errorcode_), - errormessage_(arena, from.errormessage_) {} + errormessage_(arena, from.errormessage_), + header_{visibility, arena, from.header_} {} RpcMessage::RpcMessage( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RpcMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RpcMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RpcMessage* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.body_ = (cached_has_bits & 0x00000008u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.body_) + _impl_.body_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_) : nullptr; _impl_.errortype_ = from._impl_.errortype_; // @@protoc_insertion_point(copy_constructor:protorpc.RpcMessage) } -inline PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - header_{visibility, arena}, requestid_(arena), errorclassname_(arena), errorcode_(arena), - errormessage_(arena) {} + errormessage_(arena), + header_{visibility, arena} {} -inline void RpcMessage::SharedCtor(::_pb::Arena* arena) { +inline void RpcMessage::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, body_), 0, offsetof(Impl_, errortype_) - @@ -315,110 +383,325 @@ inline void RpcMessage::SharedCtor(::_pb::Arena* arena) { } RpcMessage::~RpcMessage() { // @@protoc_insertion_point(destructor:protorpc.RpcMessage) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RpcMessage::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.errorclassname_.Destroy(); - _impl_.errorcode_.Destroy(); - _impl_.errormessage_.Destroy(); - delete _impl_.body_; - _impl_.~Impl_(); +inline void RpcMessage::SharedDtor(MessageLite& self) { + RpcMessage& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.errorclassname_.Destroy(); + this_._impl_.errorcode_.Destroy(); + this_._impl_.errormessage_.Destroy(); + delete this_._impl_.body_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RpcMessage::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RpcMessage(arena); } +constexpr auto RpcMessage::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.header_) + + decltype(RpcMessage::_impl_.header_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(RpcMessage), alignof(RpcMessage), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RpcMessage::PlacementNew_, + sizeof(RpcMessage), + alignof(RpcMessage)); + } +} +constexpr auto RpcMessage::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RpcMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcMessage::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcMessage::SharedDtor, + static_cast(&RpcMessage::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._cached_size_), + false, + }, + &RpcMessage::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_ = + RpcMessage::InternalGenerateClassData_(); -::_pbi::CachedSize* RpcMessage::AccessCachedSize() const { - return &_impl_._cached_size_; +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RpcMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RpcMessage_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RpcMessage_class_data_.tc_table); + return RpcMessage_class_data_.base(); } -void RpcMessage::InternalSwap(RpcMessage* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 2, 78, 2> +RpcMessage::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcMessage, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RpcMessage_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::RpcMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + // .google.protobuf.Any body = 2; + {::_pbi::TcParser::FastMtS1, + {18, 4, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.body_)}}, + // string requestId = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.requestid_)}}, + // optional .protorpc.RpcErrorType errorType = 4; + {::_pbi::TcParser::FastV32S1, + {32, 5, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errortype_)}}, + // optional string errorClassName = 5; + {::_pbi::TcParser::FastUS1, + {42, 1, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorclassname_)}}, + // optional string errorCode = 6; + {::_pbi::TcParser::FastUS1, + {50, 2, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorcode_)}}, + // optional string errorMessage = 7; + {::_pbi::TcParser::FastUS1, + {58, 3, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errormessage_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // map header = 1; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.header_), _Internal::kHasBitsOffset + 6, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMap)}, + // .google.protobuf.Any body = 2; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.body_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 3; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .protorpc.RpcErrorType errorType = 4; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errortype_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // optional string errorClassName = 5; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorclassname_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string errorCode = 6; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorcode_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string errorMessage = 7; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errormessage_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetMapAuxInfo( + 1, 0, 9, 9, 0)}, + }}, + {{ + "\23\6\0\11\0\16\11\14" + "protorpc.RpcMessage" + "header" + "requestId" + "errorClassName" + "errorCode" + "errorMessage" + }}, +}; +void RpcMessage::InternalSwap(RpcMessage* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RpcMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Mnfo2uhnf92hvqi2nviouq2hv9puhq::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_); - static const ::google::protobuf::Empty& empty(const Mnfo2uhnf92hvqi2nviouq2hv9puhq* msg); - static void set_has_empty(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_); }; -const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::_Internal::empty(const Mnfo2uhnf92hvqi2nviouq2hv9puhq* msg) { - return *msg->_impl_.empty_; -} void Mnfo2uhnf92hvqi2nviouq2hv9puhq::clear_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.empty_ != nullptr) _impl_.empty_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena) +Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) } -inline PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.empty_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Empty>(arena, *from._impl_.empty_) + _impl_.empty_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.empty_) : nullptr; // @@protoc_insertion_point(copy_constructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) } -inline PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedCtor(::_pb::Arena* arena) { +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.empty_ = {}; } Mnfo2uhnf92hvqi2nviouq2hv9puhq::~Mnfo2uhnf92hvqi2nviouq2hv9puhq() { // @@protoc_insertion_point(destructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - delete _impl_.empty_; - _impl_.~Impl_(); +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor(MessageLite& self) { + Mnfo2uhnf92hvqi2nviouq2hv9puhq& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.empty_; + this_._impl_.~Impl_(); } -::_pbi::CachedSize* Mnfo2uhnf92hvqi2nviouq2hv9puhq::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) Mnfo2uhnf92hvqi2nviouq2hv9puhq(arena); +} +constexpr auto Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Mnfo2uhnf92hvqi2nviouq2hv9puhq), + alignof(Mnfo2uhnf92hvqi2nviouq2hv9puhq)); } -void Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor, + static_cast(&Mnfo2uhnf92hvqi2nviouq2hv9puhq::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._cached_size_), + false, + }, + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_ = + Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +Mnfo2uhnf92hvqi2nviouq2hv9puhq::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.tc_table); + return Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +Mnfo2uhnf92hvqi2nviouq2hv9puhq::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _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), + Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .google.protobuf.Empty empty = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .google.protobuf.Empty empty = 1; + {PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Empty>()}, + }}, + {{ + }}, +}; +void Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata Mnfo2uhnf92hvqi2nviouq2hv9puhq::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace protorpc @@ -427,4 +710,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h b/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h index 97869d4b..a3861406 100644 --- a/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h +++ b/packages/streamr-dht/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/proto-rpc/protos/ProtoRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#ifndef packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#define packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,11 +24,13 @@ #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/map.h" // IWYU pragma: export +#include "google/protobuf/map_type_handler.h" // IWYU pragma: export #include "google/protobuf/map_entry.h" -#include "google/protobuf/map_field_inl.h" +#include "google/protobuf/map_field.h" #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" @@ -49,7 +45,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -58,21 +55,30 @@ class AnyMetadata; struct TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; +} // extern "C" namespace protorpc { +enum RpcErrorType : int; +extern const uint32_t RpcErrorType_internal_data_[]; class Mnfo2uhnf92hvqi2nviouq2hv9puhq; struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal; extern Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal _Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_; class RpcMessage; struct RpcMessageDefaultTypeInternal; extern RpcMessageDefaultTypeInternal _RpcMessage_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_; class RpcMessage_HeaderEntry_DoNotUse; struct RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal; extern RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal _RpcMessage_HeaderEntry_DoNotUse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_; } // namespace protorpc namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::protorpc::RpcErrorType_internal_data_> + internal::EnumTraitsImpl::value<::protorpc::RpcErrorType>; } // namespace protobuf } // namespace google @@ -84,34 +90,37 @@ enum RpcErrorType : int { CLIENT_ERROR = 3, SERVER_ERROR = 4, RpcErrorType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RpcErrorType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RpcErrorType_IsValid(int value); extern const uint32_t RpcErrorType_internal_data_[]; -constexpr RpcErrorType RpcErrorType_MIN = static_cast(0); -constexpr RpcErrorType RpcErrorType_MAX = static_cast(4); -constexpr int RpcErrorType_ARRAYSIZE = 4 + 1; -const ::google::protobuf::EnumDescriptor* -RpcErrorType_descriptor(); +inline constexpr RpcErrorType RpcErrorType_MIN = + static_cast(0); +inline constexpr RpcErrorType RpcErrorType_MAX = + static_cast(4); +inline bool RpcErrorType_IsValid(int value) { + return 0 <= value && value <= 4; +} +inline constexpr int RpcErrorType_ARRAYSIZE = 4 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcErrorType_descriptor(); template -const std::string& RpcErrorType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RpcErrorType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RpcErrorType_Name()."); return RpcErrorType_Name(static_cast(value)); } template <> -inline const std::string& RpcErrorType_Name(RpcErrorType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RpcErrorType_Name(RpcErrorType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RpcErrorType_Parse(absl::string_view name, RpcErrorType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RpcErrorType_descriptor(), name, value); +inline bool RpcErrorType_Parse( + ::absl::string_view name, RpcErrorType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RpcErrorType_descriptor(), name, + value); } // =================================================================== @@ -120,61 +129,70 @@ inline bool RpcErrorType_Parse(absl::string_view name, RpcErrorType* value) { // ------------------------------------------------------------------- class RpcMessage_HeaderEntry_DoNotUse final - : public ::google::protobuf::internal::MapEntry< - RpcMessage_HeaderEntry_DoNotUse, std::string, std::string, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING> { + : public ::google::protobuf::internal::MapEntry<::std::string, ::std::string, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING> { public: - using SuperType = ::google::protobuf::internal::MapEntry< - RpcMessage_HeaderEntry_DoNotUse, std::string, std::string, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING>; + using SuperType = + ::google::protobuf::internal::MapEntry<::std::string, ::std::string, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING>; RpcMessage_HeaderEntry_DoNotUse(); template - explicit PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse( - ::google::protobuf::internal::ConstantInitialized); - explicit RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* arena); - static const RpcMessage_HeaderEntry_DoNotUse* internal_default_instance() { - return reinterpret_cast( - &_RpcMessage_HeaderEntry_DoNotUse_default_instance_); + explicit PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::internal::ConstantInitialized); + explicit RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr const void* PROTOBUF_NONNULL internal_default_instance() { + return &_RpcMessage_HeaderEntry_DoNotUse_default_instance_; } - static bool ValidateKey(std::string* s) { - return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "protorpc.RpcMessage.HeaderEntry.key"); - } - static bool ValidateValue(std::string* s) { - return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "protorpc.RpcMessage.HeaderEntry.value"); - } - ::google::protobuf::Metadata GetMetadata() const final; + + + static constexpr auto InternalGenerateClassData_(); + + private: + friend class ::google::protobuf::MessageLite; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 48, + 2> + _table_; + + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); }; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_; // ------------------------------------------------------------------- -class RpcMessage final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protorpc.RpcMessage) */ { +class RpcMessage final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:protorpc.RpcMessage) */ { public: inline RpcMessage() : RpcMessage(nullptr) {} - ~RpcMessage() override; - template - explicit PROTOBUF_CONSTEXPR RpcMessage(::google::protobuf::internal::ConstantInitialized); + ~RpcMessage() PROTOBUF_FINAL; - inline RpcMessage(const RpcMessage& from) - : RpcMessage(nullptr, from) {} - RpcMessage(RpcMessage&& from) noexcept - : RpcMessage() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcMessage)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RpcMessage(::google::protobuf::internal::ConstantInitialized); + + inline RpcMessage(const RpcMessage& from) : RpcMessage(nullptr, from) {} + inline RpcMessage(RpcMessage&& from) noexcept + : RpcMessage(nullptr, ::std::move(from)) {} inline RpcMessage& operator=(const RpcMessage& from) { CopyFrom(from); return *this; } inline RpcMessage& operator=(RpcMessage&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -186,47 +204,35 @@ class RpcMessage final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RpcMessage& default_instance() { - return *internal_default_instance(); - } - static inline const RpcMessage* internal_default_instance() { - return reinterpret_cast( - &_RpcMessage_default_instance_); + return *reinterpret_cast( + &_RpcMessage_default_instance_); } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(RpcMessage& a, RpcMessage& b) { - a.Swap(&b); - } - inline void Swap(RpcMessage* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(RpcMessage& a, RpcMessage& b) { a.Swap(&b); } + inline void Swap(RpcMessage* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RpcMessage* other) { + void UnsafeArenaSwap(RpcMessage* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -234,138 +240,125 @@ class RpcMessage final : // implements Message ---------------------------------------------- - RpcMessage* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RpcMessage* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RpcMessage* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "protorpc.RpcMessage"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcMessage* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "protorpc.RpcMessage"; } + + explicit RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RpcMessage& from); + RpcMessage( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RpcMessage&& from) noexcept + : RpcMessage(arena) { + *this = ::std::move(from); } - protected: - explicit RpcMessage(::google::protobuf::Arena* arena); - RpcMessage(::google::protobuf::Arena* arena, const RpcMessage& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- - // accessors ------------------------------------------------------- - enum : int { - kHeaderFieldNumber = 1, kRequestIdFieldNumber = 3, kErrorClassNameFieldNumber = 5, kErrorCodeFieldNumber = 6, kErrorMessageFieldNumber = 7, kBodyFieldNumber = 2, kErrorTypeFieldNumber = 4, + kHeaderFieldNumber = 1, }; - // map header = 1; - int header_size() const; - private: - int _internal_header_size() const; - - public: - void clear_header() ; - const ::google::protobuf::Map& header() const; - ::google::protobuf::Map* mutable_header(); - - private: - const ::google::protobuf::Map& _internal_header() const; - ::google::protobuf::Map* _internal_mutable_header(); - - public: // string requestId = 3; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional string errorClassName = 5; bool has_errorclassname() const; void clear_errorclassname() ; - const std::string& errorclassname() const; - template + const ::std::string& errorclassname() const; + template void set_errorclassname(Arg_&& arg, Args_... args); - std::string* mutable_errorclassname(); - PROTOBUF_NODISCARD std::string* release_errorclassname(); - void set_allocated_errorclassname(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errorclassname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errorclassname(); + void set_allocated_errorclassname(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errorclassname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errorclassname( - const std::string& value); - std::string* _internal_mutable_errorclassname(); + const ::std::string& _internal_errorclassname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errorclassname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errorclassname(); public: // optional string errorCode = 6; bool has_errorcode() const; void clear_errorcode() ; - const std::string& errorcode() const; - template + const ::std::string& errorcode() const; + template void set_errorcode(Arg_&& arg, Args_... args); - std::string* mutable_errorcode(); - PROTOBUF_NODISCARD std::string* release_errorcode(); - void set_allocated_errorcode(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errorcode(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errorcode(); + void set_allocated_errorcode(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errorcode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errorcode( - const std::string& value); - std::string* _internal_mutable_errorcode(); + const ::std::string& _internal_errorcode() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errorcode(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errorcode(); public: // optional string errorMessage = 7; bool has_errormessage() const; void clear_errormessage() ; - const std::string& errormessage() const; - template + const ::std::string& errormessage() const; + template void set_errormessage(Arg_&& arg, Args_... args); - std::string* mutable_errormessage(); - PROTOBUF_NODISCARD std::string* release_errormessage(); - void set_allocated_errormessage(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errormessage(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errormessage(); + void set_allocated_errormessage(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errormessage() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errormessage( - const std::string& value); - std::string* _internal_mutable_errormessage(); + const ::std::string& _internal_errormessage() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errormessage(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errormessage(); public: // .google.protobuf.Any body = 2; bool has_body() const; void clear_body() ; const ::google::protobuf::Any& body() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_body(); - ::google::protobuf::Any* mutable_body(); - void set_allocated_body(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_body(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_body(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_body(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_body(); + void set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_body(); private: const ::google::protobuf::Any& _internal_body() const; - ::google::protobuf::Any* _internal_mutable_body(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_body(); public: // optional .protorpc.RpcErrorType errorType = 4; @@ -378,10 +371,30 @@ class RpcMessage final : ::protorpc::RpcErrorType _internal_errortype() const; void _internal_set_errortype(::protorpc::RpcErrorType value); + public: + // map header = 1; + int header_size() const; + private: + int _internal_header_size() const; + + public: + void clear_header() ; + const ::google::protobuf::Map<::std::string, ::std::string>& header() const; + ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL mutable_header(); + + private: + const ::google::protobuf::Map<::std::string, ::std::string>& _internal_header() const; + ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL _internal_mutable_header(); + public: // @@protoc_insertion_point(class_scope:protorpc.RpcMessage) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 2, 78, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -390,57 +403,61 @@ class RpcMessage final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RpcMessage& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::MapField - header_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr errorclassname_; ::google::protobuf::internal::ArenaStringPtr errorcode_; ::google::protobuf::internal::ArenaStringPtr errormessage_; - ::google::protobuf::Any* body_; + ::google::protobuf::Any* PROTOBUF_NULLABLE body_; int errortype_; + ::google::protobuf::internal::MapField + header_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_; +// ------------------------------------------------------------------- -class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) */ { +class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) */ { public: inline Mnfo2uhnf92hvqi2nviouq2hv9puhq() : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr) {} - ~Mnfo2uhnf92hvqi2nviouq2hv9puhq() override; - template - explicit PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::internal::ConstantInitialized); + ~Mnfo2uhnf92hvqi2nviouq2hv9puhq() PROTOBUF_FINAL; - inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) - : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, from) {} - Mnfo2uhnf92hvqi2nviouq2hv9puhq(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept - : Mnfo2uhnf92hvqi2nviouq2hv9puhq() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Mnfo2uhnf92hvqi2nviouq2hv9puhq)); } +#endif + template + explicit PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::internal::ConstantInitialized); + + inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, from) {} + inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept + : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, ::std::move(from)) {} inline Mnfo2uhnf92hvqi2nviouq2hv9puhq& operator=(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) { CopyFrom(from); return *this; } inline Mnfo2uhnf92hvqi2nviouq2hv9puhq& operator=(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -452,47 +469,35 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const Mnfo2uhnf92hvqi2nviouq2hv9puhq& default_instance() { - return *internal_default_instance(); - } - static inline const Mnfo2uhnf92hvqi2nviouq2hv9puhq* internal_default_instance() { - return reinterpret_cast( - &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq& a, Mnfo2uhnf92hvqi2nviouq2hv9puhq& b) { - a.Swap(&b); + return *reinterpret_cast( + &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_); } - inline void Swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq& a, Mnfo2uhnf92hvqi2nviouq2hv9puhq& b) { a.Swap(&b); } + inline void Swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other) { + void UnsafeArenaSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -500,33 +505,40 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : // implements Message ---------------------------------------------- - Mnfo2uhnf92hvqi2nviouq2hv9puhq* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq"; } + + explicit Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from); + Mnfo2uhnf92hvqi2nviouq2hv9puhq( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept + : Mnfo2uhnf92hvqi2nviouq2hv9puhq(arena) { + *this = ::std::move(from); } - protected: - explicit Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena); - Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEmptyFieldNumber = 1, }; @@ -534,20 +546,25 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : bool has_empty() const; void clear_empty() ; const ::google::protobuf::Empty& empty() const; - PROTOBUF_NODISCARD ::google::protobuf::Empty* release_empty(); - ::google::protobuf::Empty* mutable_empty(); - void set_allocated_empty(::google::protobuf::Empty* value); - void unsafe_arena_set_allocated_empty(::google::protobuf::Empty* value); - ::google::protobuf::Empty* unsafe_arena_release_empty(); + [[nodiscard]] ::google::protobuf::Empty* PROTOBUF_NULLABLE release_empty(); + ::google::protobuf::Empty* PROTOBUF_NONNULL mutable_empty(); + void set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value); + ::google::protobuf::Empty* PROTOBUF_NULLABLE unsafe_arena_release_empty(); private: const ::google::protobuf::Empty& _internal_empty() const; - ::google::protobuf::Empty* _internal_mutable_empty(); + ::google::protobuf::Empty* PROTOBUF_NONNULL _internal_mutable_empty(); public: // @@protoc_insertion_point(class_scope:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) 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; @@ -556,22 +573,25 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::Empty* empty_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::Empty* PROTOBUF_NULLABLE empty_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_; + // =================================================================== @@ -598,34 +618,38 @@ inline int RpcMessage::header_size() const { return _internal_header_size(); } inline void RpcMessage::clear_header() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000040U); } -inline const ::google::protobuf::Map& RpcMessage::_internal_header() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::google::protobuf::Map<::std::string, ::std::string>& RpcMessage::_internal_header() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.header_.GetMap(); } -inline const ::google::protobuf::Map& RpcMessage::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::Map<::std::string, ::std::string>& RpcMessage::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_map:protorpc.RpcMessage.header) return _internal_header(); } -inline ::google::protobuf::Map* RpcMessage::_internal_mutable_header() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL RpcMessage::_internal_mutable_header() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.header_.MutableMap(); } -inline ::google::protobuf::Map* RpcMessage::mutable_header() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL RpcMessage::mutable_header() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_mutable_map:protorpc.RpcMessage.header) return _internal_mutable_header(); } // .google.protobuf.Any body = 2; inline bool RpcMessage::has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); return value; } inline const ::google::protobuf::Any& RpcMessage::_internal_body() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.body_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -633,76 +657,78 @@ inline const ::google::protobuf::Any& RpcMessage::body() const ABSL_ATTRIBUTE_LI // @@protoc_insertion_point(field_get:protorpc.RpcMessage.body) return _internal_body(); } -inline void RpcMessage::unsafe_arena_set_allocated_body(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::unsafe_arena_set_allocated_body( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protorpc.RpcMessage.body) } -inline ::google::protobuf::Any* RpcMessage::release_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE RpcMessage::release_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* released = _impl_.body_; _impl_.body_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* RpcMessage::unsafe_arena_release_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE RpcMessage::unsafe_arena_release_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.body) - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* temp = _impl_.body_; _impl_.body_ = nullptr; return temp; } -inline ::google::protobuf::Any* RpcMessage::_internal_mutable_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000008u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL RpcMessage::_internal_mutable_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.body_; } -inline ::google::protobuf::Any* RpcMessage::mutable_body() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL RpcMessage::mutable_body() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* _msg = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.body) return _msg; } -inline void RpcMessage::set_allocated_body(::google::protobuf::Any* value) { +inline void RpcMessage::set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -711,66 +737,79 @@ inline void RpcMessage::set_allocated_body(::google::protobuf::Any* value) { // string requestId = 3; inline void RpcMessage::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RpcMessage::requestid() const +inline const ::std::string& RpcMessage::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.requestId) } -inline std::string* RpcMessage::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.requestId) return _s; } -inline const std::string& RpcMessage::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RpcMessage::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RpcMessage::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RpcMessage::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.requestId) } // optional .protorpc.RpcErrorType errorType = 4; inline bool RpcMessage::has_errortype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); return value; } inline void RpcMessage::clear_errortype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errortype_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline ::protorpc::RpcErrorType RpcMessage::errortype() const { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorType) @@ -778,228 +817,222 @@ inline ::protorpc::RpcErrorType RpcMessage::errortype() const { } inline void RpcMessage::set_errortype(::protorpc::RpcErrorType value) { _internal_set_errortype(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorType) } inline ::protorpc::RpcErrorType RpcMessage::_internal_errortype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::protorpc::RpcErrorType>(_impl_.errortype_); } inline void RpcMessage::_internal_set_errortype(::protorpc::RpcErrorType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000010u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errortype_ = value; } // optional string errorClassName = 5; inline bool RpcMessage::has_errorclassname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void RpcMessage::clear_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorclassname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RpcMessage::errorclassname() const +inline const ::std::string& RpcMessage::errorclassname() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorClassName) return _internal_errorclassname(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorclassname(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorclassname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.errorclassname_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorClassName) } -inline std::string* RpcMessage::mutable_errorclassname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errorclassname(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errorclassname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_errorclassname(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorClassName) return _s; } -inline const std::string& RpcMessage::_internal_errorclassname() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errorclassname() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errorclassname_.Get(); } -inline void RpcMessage::_internal_set_errorclassname(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void RpcMessage::_internal_set_errorclassname(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorclassname_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errorclassname() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errorclassname_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errorclassname() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorClassName) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); auto* released = _impl_.errorclassname_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errorclassname_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errorclassname_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errorclassname(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errorclassname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.errorclassname_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errorclassname_.IsDefault()) { - _impl_.errorclassname_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errorclassname_.IsDefault()) { + _impl_.errorclassname_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorClassName) } // optional string errorCode = 6; inline bool RpcMessage::has_errorcode() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void RpcMessage::clear_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorcode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& RpcMessage::errorcode() const +inline const ::std::string& RpcMessage::errorcode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorCode) return _internal_errorcode(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorcode(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorcode(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.errorcode_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorCode) } -inline std::string* RpcMessage::mutable_errorcode() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errorcode(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errorcode() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_errorcode(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorCode) return _s; } -inline const std::string& RpcMessage::_internal_errorcode() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errorcode() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errorcode_.Get(); } -inline void RpcMessage::_internal_set_errorcode(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline void RpcMessage::_internal_set_errorcode(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorcode_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errorcode() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errorcode_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errorcode() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorCode) - if ((_impl_._has_bits_[0] & 0x00000002u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); auto* released = _impl_.errorcode_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errorcode_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errorcode_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errorcode(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errorcode(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.errorcode_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errorcode_.IsDefault()) { - _impl_.errorcode_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errorcode_.IsDefault()) { + _impl_.errorcode_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorCode) } // optional string errorMessage = 7; inline bool RpcMessage::has_errormessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); return value; } inline void RpcMessage::clear_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errormessage_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& RpcMessage::errormessage() const +inline const ::std::string& RpcMessage::errormessage() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorMessage) return _internal_errormessage(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errormessage(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errormessage(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.errormessage_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorMessage) } -inline std::string* RpcMessage::mutable_errormessage() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errormessage(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errormessage() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_errormessage(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorMessage) return _s; } -inline const std::string& RpcMessage::_internal_errormessage() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errormessage() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errormessage_.Get(); } -inline void RpcMessage::_internal_set_errormessage(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline void RpcMessage::_internal_set_errormessage(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errormessage_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errormessage() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errormessage_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errormessage() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorMessage) - if ((_impl_._has_bits_[0] & 0x00000004u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); auto* released = _impl_.errormessage_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errormessage_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errormessage_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errormessage(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errormessage(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.errormessage_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errormessage_.IsDefault()) { - _impl_.errormessage_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errormessage_.IsDefault()) { + _impl_.errormessage_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorMessage) } @@ -1009,12 +1042,12 @@ inline void RpcMessage::set_allocated_errormessage(std::string* value) { // .google.protobuf.Empty empty = 1; inline bool Mnfo2uhnf92hvqi2nviouq2hv9puhq::has_empty() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); PROTOBUF_ASSUME(!value || _impl_.empty_ != nullptr); return value; } inline const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_empty() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Empty* p = _impl_.empty_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Empty_default_instance_); } @@ -1022,76 +1055,78 @@ inline const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::empty() // @@protoc_insertion_point(field_get:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) return _internal_empty(); } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_set_allocated_empty(::google::protobuf::Empty* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_set_allocated_empty( + ::google::protobuf::Empty* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.empty_); } _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::release_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Empty* PROTOBUF_NULLABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq::release_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* released = _impl_.empty_; _impl_.empty_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_release_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Empty* PROTOBUF_NULLABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_release_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* temp = _impl_.empty_; _impl_.empty_ = nullptr; return temp; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_mutable_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Empty* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_mutable_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.empty_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Empty>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Empty>(GetArena()); _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(p); } return _impl_.empty_; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::mutable_empty() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Empty* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::mutable_empty() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* _msg = _internal_mutable_empty(); // @@protoc_insertion_point(field_mutable:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) return _msg; } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::set_allocated_empty(::google::protobuf::Empty* value) { +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.empty_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(value); @@ -1112,7 +1147,7 @@ namespace protobuf { template <> struct is_proto_enum<::protorpc::RpcErrorType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::protorpc::RpcErrorType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::protorpc::RpcErrorType>() { return ::protorpc::RpcErrorType_descriptor(); } @@ -1123,4 +1158,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::protorpc::RpcErrorType>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#endif // packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh diff --git a/packages/streamr-libstreamrproxyclient/dist/arm64-osx/include/streamrproxyclient.h b/packages/streamr-libstreamrproxyclient/dist/arm64-osx/include/streamrproxyclient.h new file mode 100644 index 00000000..63bb408f --- /dev/null +++ b/packages/streamr-libstreamrproxyclient/dist/arm64-osx/include/streamrproxyclient.h @@ -0,0 +1,164 @@ +#ifndef LIBSTREAMRPROXYCLIENT_H +#define LIBSTREAMRPROXYCLIENT_H + +// NOLINTNEXTLINE +#include + +#if defined(__clang__) || defined(__GNUC__) +#define SHARED_EXPORT __attribute__((visibility("default"))) +#define SHARED_LOCAL __attribute__((visibility("hidden"))) +#else +#define SHARED_EXPORT +#define SHARED_LOCAL +#endif + +#ifdef __cplusplus +#define EXTERN_C extern "C" +#else +#define EXTERN_C +#endif + +#define ERROR_INVALID_ETHEREUM_ADDRESS "INVALID_ETHEREUM_ADDRESS" +#define ERROR_INVALID_STREAM_PART_ID "INVALID_STREAM_PART_ID" +#define ERROR_PROXY_CLIENT_NOT_FOUND "PROXY_CLIENT_NOT_FOUND" +#define ERROR_INVALID_PROXY_URL "INVALID_PROXY_URL" +#define ERROR_NO_PROXIES_DEFINED "NO_PROXIES_DEFINED" +#define ERROR_PROXY_CONNECTION_FAILED "PROXY_CONNECTION_FAILED" +#define ERROR_PROXY_BROADCAST_FAILED "PROXY_BROADCAST_FAILED" + +EXTERN_C SHARED_EXPORT const char* testRpc(void); + +// NOLINTNEXTLINE +SHARED_EXPORT static void __attribute__((constructor)) initialize(void); + + +/** + * @brief Initialize the library. This function is called automatically when the library is loaded, + * but can be called explicitly to force a re-initialization (e.g. after proxyClientCleanupLibrary() has been called). + */ + +// NOLINTNEXTLINE +EXTERN_C SHARED_EXPORT void proxyClientInitLibrary(void); + +/** + * @brief Cleanup the library. This function MUST be called before the program exits. + * Can be safely called multiple times. This is needed because the standard dynamic library + * destructor (__attribute__((destructor))) is called after static variables have already been destroyed, + * which makes it impossible to clean up the other objects that depend on the static variables. + */ +// NOLINTNEXTLINE +EXTERN_C SHARED_EXPORT void proxyClientCleanupLibrary(void); + + +// NOLINTNEXTLINE +typedef struct Proxy { + const char* websocketUrl; + const char* ethereumAddress; +} Proxy; + +// NOLINTNEXTLINE +typedef struct Error { + const char* message; + const char* code; + const struct Proxy* proxy; +} Error; + +// NOLINTNEXTLINE +typedef struct ProxyResult { + Error* errors; + uint64_t numErrors; + Proxy* successful; + uint64_t numSuccessful; +} ProxyResult; + +/** + * @brief Delete a ProxyResult. This method must be called after every call that + * returns a ProxyResult. + * @param proxyResult The ProxyResult to delete. + */ + +EXTERN_C SHARED_EXPORT void proxyClientResultDelete(const ProxyResult* proxyResult); + +/** + * @brief Create a new proxy client. + * + * @param proxyResult Pointer in which ProxyResult will be stored. You MUST call + * proxyClientResultDelete() on this after the call returns. The resulting ProxyResult + * may only contain "errors" - the "successful" and "numSuccessful" fields are + * unused. + * @param ownEthereumAddress The Ethereum address of the client in format + * 0x1234567890123456789012345678901234567890. + * @param streamPartId The stream part id in format + * 0xa000000000000000000000000000000000000000#01. + * @return The handle of the created client. + */ + +EXTERN_C SHARED_EXPORT uint64_t proxyClientNew( + const ProxyResult** proxyResult, + const char* ownEthereumAddress, + const char* streamPartId); + +/** + * @brief Delete a proxy client. + * + * @param proxyResult Pointer in which ProxyResult will be stored. You MUST call + * proxyClientResultDelete() on this after the call returns. The resulting ProxyResult + * may only contain "errors" - the "successful" and "numSuccessful" fields are + * unused. + * @param clientHandle The client handle of the client to delete. + */ + +EXTERN_C SHARED_EXPORT void proxyClientDelete( + const ProxyResult** proxyResult, uint64_t clientHandle); + +/** + * @brief Connect a proxy client to a list of proxies. + * + * @param proxyResult Pointer in which ProxyResult will be stored. You MUST call + * proxyClientResultDelete() on this after the call returns. + * @param clientHandle The client handle of the client to connect. + * @param proxies The array of proxies. + * @param numProxies The number of proxies. + * @return The number of proxies connected to. + */ + +EXTERN_C SHARED_EXPORT uint64_t proxyClientConnect( + const ProxyResult** proxyResult, + uint64_t clientHandle, + const Proxy* proxies, + uint64_t numProxies); + +/** + * @brief Disconnect a proxy client from all proxies. + * + * @param proxyResult Pointer in which ProxyResult will be stored. You MUST call + * proxyClientResultDelete() on this after the call returns. The resulting ProxyResult + * may only contain "errors" - the "successful" and "numSuccessful" fields are + * unused. + * @param clientHandle The client handle of the client to disconnect. + +EXTERN_C SHARED_EXPORT void proxyClientDisconnect( + const ProxyResult** proxyResult, uint64_t clientHandle); +*/ + +/** + * @brief Publish a message to the stream. + * + * @param proxyResult Pointer in which ProxyResult will be stored. You MUST call + * proxyClientResultDelete() on this after the call returns. + * @param clientHandle The client handle of the client to publish. + * @param content The content to publish. + * @param contentLength The length of the content. + * @param ethereumPrivateKey as hex without 0x prefix (64 characters) or NULL if + * message should not be signed. + * @return The number of proxies to which the message was published to. + */ + +EXTERN_C SHARED_EXPORT uint64_t proxyClientPublish( + const ProxyResult** proxyResult, + uint64_t clientHandle, + const char* content, + uint64_t contentLength, + const char* ethereumPrivateKey); + +#endif /* LIBSTREAMRPROXYCLIENT_H */ diff --git a/packages/streamr-proto-rpc/CMakeLists.txt b/packages/streamr-proto-rpc/CMakeLists.txt index 4ebe1830..166b97e0 100644 --- a/packages/streamr-proto-rpc/CMakeLists.txt +++ b/packages/streamr-proto-rpc/CMakeLists.txt @@ -19,7 +19,6 @@ set (VCPKG_OVERLAY_TRIPLETS ENV{VCPKG_OVERLAY_TRIPLETS}) set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake") project(proto-rpc CXX) -add_compile_options(-fpermissive) find_package(streamr-logger CONFIG REQUIRED) find_package(streamr-eventemitter CONFIG REQUIRED) find_package(streamr-utils CONFIG REQUIRED) @@ -51,7 +50,6 @@ target_link_libraries(streamr-proto-rpc INTERFACE streamr::streamr-eventemitter INTERFACE streamr::streamr-utils PRIVATE protobuf::libprotobuf - PRIVATE protobuf::libprotoc INTERFACE Boost::uuid PRIVATE magic_enum::magic_enum PUBLIC Folly::folly diff --git a/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.cc b/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.cc index 13ea014c..21006f1f 100644 --- a/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.cc +++ b/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: HelloRpc.proto +// Protobuf C++ Version: 6.33.4 #include "HelloRpc.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" @@ -18,17 +23,24 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; inline constexpr HelloResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : greeting_( + : _cached_size_{0}, + greeting_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR HelloResponse::HelloResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HelloResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HelloResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR HelloResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HelloResponseDefaultTypeInternal() {} @@ -42,14 +54,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr HelloRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : myname_( + : _cached_size_{0}, + myname_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR HelloRequest::HelloRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HelloRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HelloRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR HelloRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HelloRequestDefaultTypeInternal() {} @@ -60,51 +78,43 @@ struct HelloRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HelloRequestDefaultTypeInternal _HelloRequest_default_instance_; -static ::_pb::Metadata file_level_metadata_HelloRpc_2eproto[2]; -static constexpr const ::_pb::EnumDescriptor** +static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_enum_descriptors_HelloRpc_2eproto = nullptr; -static constexpr const ::_pb::ServiceDescriptor** +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_HelloRpc_2eproto = nullptr; -const ::uint32_t TableStruct_HelloRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::HelloRequest, _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(::HelloRequest, _impl_.myname_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::HelloResponse, _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(::HelloResponse, _impl_.greeting_), +const ::uint32_t + TableStruct_HelloRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::HelloRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::HelloRequest, _impl_.myname_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::HelloResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::HelloResponse, _impl_.greeting_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, -1, -1, sizeof(::HelloRequest)}, - {9, -1, -1, sizeof(::HelloResponse)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::HelloRequest)}, + {5, sizeof(::HelloResponse)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::_HelloRequest_default_instance_._instance, &::_HelloResponse_default_instance_._instance, }; -const char descriptor_table_protodef_HelloRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_HelloRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n\016HelloRpc.proto\"\036\n\014HelloRequest\022\016\n\006myNa" "me\030\001 \001(\t\"!\n\rHelloResponse\022\020\n\010greeting\030\001 " "\001(\t2<\n\017HelloRpcService\022)\n\010sayHello\022\r.Hel" "loRequest\032\016.HelloResponseB\002H\002b\006proto3" }; static ::absl::once_flag descriptor_table_HelloRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_HelloRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_HelloRpc_2eproto = { false, false, 157, @@ -117,149 +127,316 @@ const ::_pbi::DescriptorTable descriptor_table_HelloRpc_2eproto = { schemas, file_default_instances, TableStruct_HelloRpc_2eproto::offsets, - file_level_metadata_HelloRpc_2eproto, file_level_enum_descriptors_HelloRpc_2eproto, file_level_service_descriptors_HelloRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_HelloRpc_2eproto_getter() { - return &descriptor_table_HelloRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_HelloRpc_2eproto(&descriptor_table_HelloRpc_2eproto); // =================================================================== class HelloRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_._has_bits_); }; -HelloRequest::HelloRequest(::google::protobuf::Arena* arena) +HelloRequest::HelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:HelloRequest) } -inline PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : myname_(arena, from.myname_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::HelloRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + myname_(arena, from.myname_) {} HelloRequest::HelloRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HelloRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:HelloRequest) } -inline PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : myname_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + myname_(arena) {} -inline void HelloRequest::SharedCtor(::_pb::Arena* arena) { +inline void HelloRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } HelloRequest::~HelloRequest() { // @@protoc_insertion_point(destructor:HelloRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void HelloRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.myname_.Destroy(); - _impl_.~Impl_(); +inline void HelloRequest::SharedDtor(MessageLite& self) { + HelloRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.myname_.Destroy(); + this_._impl_.~Impl_(); } -::_pbi::CachedSize* HelloRequest::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL HelloRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HelloRequest(arena); +} +constexpr auto HelloRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HelloRequest), + alignof(HelloRequest)); } -void HelloRequest::InternalSwap(HelloRequest* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto HelloRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HelloRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HelloRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HelloRequest::SharedDtor, + static_cast(&HelloRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_._cached_size_), + false, + }, + &HelloRequest::kDescriptorMethods, + &descriptor_table_HelloRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HelloRequest_class_data_ = + HelloRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HelloRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HelloRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HelloRequest_class_data_.tc_table); + return HelloRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 27, 2> +HelloRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HelloRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + HelloRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::HelloRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string myName = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_.myname_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string myName = 1; + {PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_.myname_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\14\6\0\0\0\0\0\0" + "HelloRequest" + "myName" + }}, +}; +void HelloRequest::InternalSwap(HelloRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HelloRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_HelloRpc_2eproto_getter, &descriptor_table_HelloRpc_2eproto_once, - file_level_metadata_HelloRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HelloResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_._has_bits_); }; -HelloResponse::HelloResponse(::google::protobuf::Arena* arena) +HelloResponse::HelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:HelloResponse) } -inline PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : greeting_(arena, from.greeting_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::HelloResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + greeting_(arena, from.greeting_) {} HelloResponse::HelloResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HelloResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:HelloResponse) } -inline PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : greeting_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + greeting_(arena) {} -inline void HelloResponse::SharedCtor(::_pb::Arena* arena) { +inline void HelloResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } HelloResponse::~HelloResponse() { // @@protoc_insertion_point(destructor:HelloResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); +} +inline void HelloResponse::SharedDtor(MessageLite& self) { + HelloResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.greeting_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL HelloResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HelloResponse(arena); +} +constexpr auto HelloResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HelloResponse), + alignof(HelloResponse)); } -inline void HelloResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.greeting_.Destroy(); - _impl_.~Impl_(); +constexpr auto HelloResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HelloResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HelloResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HelloResponse::SharedDtor, + static_cast(&HelloResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_._cached_size_), + false, + }, + &HelloResponse::kDescriptorMethods, + &descriptor_table_HelloRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* HelloResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HelloResponse_class_data_ = + HelloResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HelloResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HelloResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HelloResponse_class_data_.tc_table); + return HelloResponse_class_data_.base(); } -void HelloResponse::InternalSwap(HelloResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 30, 2> +HelloResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HelloResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + HelloResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::HelloResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string greeting = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_.greeting_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string greeting = 1; + {PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_.greeting_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\15\10\0\0\0\0\0\0" + "HelloResponse" + "greeting" + }}, +}; +void HelloResponse::InternalSwap(HelloResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HelloResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_HelloRpc_2eproto_getter, &descriptor_table_HelloRpc_2eproto_once, - file_level_metadata_HelloRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) namespace google { @@ -267,4 +444,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_HelloRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.h b/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.h index 894d25a3..00b666ef 100644 --- a/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.h +++ b/packages/streamr-proto-rpc/examples/hello/proto/HelloRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: HelloRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_HelloRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_HelloRpc_2eproto_2epb_2eh +#ifndef HelloRpc_2eproto_2epb_2eh +#define HelloRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,6 +24,7 @@ #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" @@ -43,7 +38,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -52,14 +48,17 @@ class AnyMetadata; struct TableStruct_HelloRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_HelloRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_HelloRpc_2eproto; +} // extern "C" class HelloRequest; struct HelloRequestDefaultTypeInternal; extern HelloRequestDefaultTypeInternal _HelloRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HelloRequest_class_data_; class HelloResponse; struct HelloResponseDefaultTypeInternal; extern HelloResponseDefaultTypeInternal _HelloResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HelloResponse_class_data_; namespace google { namespace protobuf { } // namespace protobuf @@ -71,32 +70,32 @@ namespace protobuf { // ------------------------------------------------------------------- -class HelloResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:HelloResponse) */ { +class HelloResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:HelloResponse) */ { public: inline HelloResponse() : HelloResponse(nullptr) {} - ~HelloResponse() override; - template - explicit PROTOBUF_CONSTEXPR HelloResponse(::google::protobuf::internal::ConstantInitialized); + ~HelloResponse() PROTOBUF_FINAL; - inline HelloResponse(const HelloResponse& from) - : HelloResponse(nullptr, from) {} - HelloResponse(HelloResponse&& from) noexcept - : HelloResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HelloResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HelloResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HelloResponse(::google::protobuf::internal::ConstantInitialized); + inline HelloResponse(const HelloResponse& from) : HelloResponse(nullptr, from) {} + inline HelloResponse(HelloResponse&& from) noexcept + : HelloResponse(nullptr, ::std::move(from)) {} inline HelloResponse& operator=(const HelloResponse& from) { CopyFrom(from); return *this; } inline HelloResponse& operator=(HelloResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -108,47 +107,35 @@ class HelloResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HelloResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_HelloResponse_default_instance_); } - static inline const HelloResponse* internal_default_instance() { - return reinterpret_cast( - &_HelloResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(HelloResponse& a, HelloResponse& b) { - a.Swap(&b); - } - inline void Swap(HelloResponse* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(HelloResponse& a, HelloResponse& b) { a.Swap(&b); } + inline void Swap(HelloResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HelloResponse* other) { + void UnsafeArenaSwap(HelloResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -156,55 +143,66 @@ class HelloResponse final : // implements Message ---------------------------------------------- - HelloResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HelloResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HelloResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "HelloResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HelloResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "HelloResponse"; } + + explicit HelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloResponse& from); + HelloResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HelloResponse&& from) noexcept + : HelloResponse(arena) { + *this = ::std::move(from); } - protected: - explicit HelloResponse(::google::protobuf::Arena* arena); - HelloResponse(::google::protobuf::Arena* arena, const HelloResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kGreetingFieldNumber = 1, }; // string greeting = 1; void clear_greeting() ; - const std::string& greeting() const; - template + const ::std::string& greeting() const; + template void set_greeting(Arg_&& arg, Args_... args); - std::string* mutable_greeting(); - PROTOBUF_NODISCARD std::string* release_greeting(); - void set_allocated_greeting(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_greeting(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_greeting(); + void set_allocated_greeting(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_greeting() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_greeting( - const std::string& value); - std::string* _internal_mutable_greeting(); + const ::std::string& _internal_greeting() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_greeting(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_greeting(); public: // @@protoc_insertion_point(class_scope:HelloResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 30, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -213,47 +211,52 @@ class HelloResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HelloResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr greeting_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_HelloRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull HelloResponse_class_data_; +// ------------------------------------------------------------------- -class HelloRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:HelloRequest) */ { +class HelloRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:HelloRequest) */ { public: inline HelloRequest() : HelloRequest(nullptr) {} - ~HelloRequest() override; - template - explicit PROTOBUF_CONSTEXPR HelloRequest(::google::protobuf::internal::ConstantInitialized); + ~HelloRequest() PROTOBUF_FINAL; - inline HelloRequest(const HelloRequest& from) - : HelloRequest(nullptr, from) {} - HelloRequest(HelloRequest&& from) noexcept - : HelloRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HelloRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HelloRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HelloRequest(::google::protobuf::internal::ConstantInitialized); + inline HelloRequest(const HelloRequest& from) : HelloRequest(nullptr, from) {} + inline HelloRequest(HelloRequest&& from) noexcept + : HelloRequest(nullptr, ::std::move(from)) {} inline HelloRequest& operator=(const HelloRequest& from) { CopyFrom(from); return *this; } inline HelloRequest& operator=(HelloRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -265,47 +268,35 @@ class HelloRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HelloRequest& default_instance() { - return *internal_default_instance(); - } - static inline const HelloRequest* internal_default_instance() { - return reinterpret_cast( - &_HelloRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(HelloRequest& a, HelloRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_HelloRequest_default_instance_); } - inline void Swap(HelloRequest* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(HelloRequest& a, HelloRequest& b) { a.Swap(&b); } + inline void Swap(HelloRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HelloRequest* other) { + void UnsafeArenaSwap(HelloRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -313,55 +304,66 @@ class HelloRequest final : // implements Message ---------------------------------------------- - HelloRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HelloRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HelloRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "HelloRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HelloRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "HelloRequest"; } + + explicit HelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloRequest& from); + HelloRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HelloRequest&& from) noexcept + : HelloRequest(arena) { + *this = ::std::move(from); } - protected: - explicit HelloRequest(::google::protobuf::Arena* arena); - HelloRequest(::google::protobuf::Arena* arena, const HelloRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kMyNameFieldNumber = 1, }; // string myName = 1; void clear_myname() ; - const std::string& myname() const; - template + const ::std::string& myname() const; + template void set_myname(Arg_&& arg, Args_... args); - std::string* mutable_myname(); - PROTOBUF_NODISCARD std::string* release_myname(); - void set_allocated_myname(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_myname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_myname(); + void set_allocated_myname(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_myname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_myname( - const std::string& value); - std::string* _internal_mutable_myname(); + const ::std::string& _internal_myname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_myname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_myname(); public: // @@protoc_insertion_point(class_scope:HelloRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 27, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -370,21 +372,25 @@ class HelloRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HelloRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr myname_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_HelloRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull HelloRequest_class_data_; + // =================================================================== @@ -403,54 +409,66 @@ class HelloRequest final : // string myName = 1; inline void HelloRequest::clear_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.myname_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HelloRequest::myname() const +inline const ::std::string& HelloRequest::myname() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:HelloRequest.myName) return _internal_myname(); } template -inline PROTOBUF_ALWAYS_INLINE void HelloRequest::set_myname(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HelloRequest::set_myname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.myname_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:HelloRequest.myName) } -inline std::string* HelloRequest::mutable_myname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_myname(); +inline ::std::string* PROTOBUF_NONNULL HelloRequest::mutable_myname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_myname(); // @@protoc_insertion_point(field_mutable:HelloRequest.myName) return _s; } -inline const std::string& HelloRequest::_internal_myname() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HelloRequest::_internal_myname() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.myname_.Get(); } -inline void HelloRequest::_internal_set_myname(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HelloRequest::_internal_set_myname(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.myname_.Set(value, GetArena()); } -inline std::string* HelloRequest::_internal_mutable_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HelloRequest::_internal_mutable_myname() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.myname_.Mutable( GetArena()); } -inline std::string* HelloRequest::release_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HelloRequest::release_myname() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:HelloRequest.myName) - return _impl_.myname_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.myname_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.myname_.Set("", GetArena()); + } + return released; } -inline void HelloRequest::set_allocated_myname(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HelloRequest::set_allocated_myname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.myname_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.myname_.IsDefault()) { - _impl_.myname_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.myname_.IsDefault()) { + _impl_.myname_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:HelloRequest.myName) } @@ -460,54 +478,66 @@ inline void HelloRequest::set_allocated_myname(std::string* value) { // string greeting = 1; inline void HelloResponse::clear_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.greeting_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HelloResponse::greeting() const +inline const ::std::string& HelloResponse::greeting() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:HelloResponse.greeting) return _internal_greeting(); } template -inline PROTOBUF_ALWAYS_INLINE void HelloResponse::set_greeting(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HelloResponse::set_greeting(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.greeting_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:HelloResponse.greeting) } -inline std::string* HelloResponse::mutable_greeting() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_greeting(); +inline ::std::string* PROTOBUF_NONNULL HelloResponse::mutable_greeting() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_greeting(); // @@protoc_insertion_point(field_mutable:HelloResponse.greeting) return _s; } -inline const std::string& HelloResponse::_internal_greeting() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HelloResponse::_internal_greeting() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.greeting_.Get(); } -inline void HelloResponse::_internal_set_greeting(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HelloResponse::_internal_set_greeting(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.greeting_.Set(value, GetArena()); } -inline std::string* HelloResponse::_internal_mutable_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HelloResponse::_internal_mutable_greeting() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.greeting_.Mutable( GetArena()); } -inline std::string* HelloResponse::release_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HelloResponse::release_greeting() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:HelloResponse.greeting) - return _impl_.greeting_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.greeting_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.greeting_.Set("", GetArena()); + } + return released; } -inline void HelloResponse::set_allocated_greeting(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HelloResponse::set_allocated_greeting(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.greeting_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.greeting_.IsDefault()) { - _impl_.greeting_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.greeting_.IsDefault()) { + _impl_.greeting_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:HelloResponse.greeting) } @@ -522,4 +552,4 @@ inline void HelloResponse::set_allocated_greeting(std::string* value) { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_HelloRpc_2eproto_2epb_2eh +#endif // HelloRpc_2eproto_2epb_2eh diff --git a/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.cc b/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.cc index f913a432..662b9e93 100644 --- a/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.cc +++ b/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: RoutedHelloRpc.proto +// Protobuf C++ Version: 6.33.4 #include "RoutedHelloRpc.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" @@ -18,17 +23,24 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; inline constexpr RoutedHelloResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : greeting_( + : _cached_size_{0}, + greeting_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR RoutedHelloResponse::RoutedHelloResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RoutedHelloResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RoutedHelloResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR RoutedHelloResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RoutedHelloResponseDefaultTypeInternal() {} @@ -42,14 +54,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RoutedHelloRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : myname_( + : _cached_size_{0}, + myname_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR RoutedHelloRequest::RoutedHelloRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RoutedHelloRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RoutedHelloRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR RoutedHelloRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RoutedHelloRequestDefaultTypeInternal() {} @@ -60,44 +78,36 @@ struct RoutedHelloRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RoutedHelloRequestDefaultTypeInternal _RoutedHelloRequest_default_instance_; -static ::_pb::Metadata file_level_metadata_RoutedHelloRpc_2eproto[2]; -static constexpr const ::_pb::EnumDescriptor** +static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_enum_descriptors_RoutedHelloRpc_2eproto = nullptr; -static constexpr const ::_pb::ServiceDescriptor** +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_RoutedHelloRpc_2eproto = nullptr; -const ::uint32_t TableStruct_RoutedHelloRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::RoutedHelloRequest, _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(::RoutedHelloRequest, _impl_.myname_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::RoutedHelloResponse, _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(::RoutedHelloResponse, _impl_.greeting_), +const ::uint32_t + TableStruct_RoutedHelloRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::RoutedHelloRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::RoutedHelloRequest, _impl_.myname_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::RoutedHelloResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::RoutedHelloResponse, _impl_.greeting_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, -1, -1, sizeof(::RoutedHelloRequest)}, - {9, -1, -1, sizeof(::RoutedHelloResponse)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::RoutedHelloRequest)}, + {5, sizeof(::RoutedHelloResponse)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::_RoutedHelloRequest_default_instance_._instance, &::_RoutedHelloResponse_default_instance_._instance, }; -const char descriptor_table_protodef_RoutedHelloRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_RoutedHelloRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n\024RoutedHelloRpc.proto\"$\n\022RoutedHelloReq" "uest\022\016\n\006myName\030\001 \001(\t\"\'\n\023RoutedHelloRespo" "nse\022\020\n\010greeting\030\001 \001(\t2N\n\025RoutedHelloRpcS" @@ -105,7 +115,7 @@ const char descriptor_table_protodef_RoutedHelloRpc_2eproto[] PROTOBUF_SECTION_V "\024.RoutedHelloResponseB\002H\002b\006proto3" }; static ::absl::once_flag descriptor_table_RoutedHelloRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_RoutedHelloRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_RoutedHelloRpc_2eproto = { false, false, 193, @@ -118,149 +128,316 @@ const ::_pbi::DescriptorTable descriptor_table_RoutedHelloRpc_2eproto = { schemas, file_default_instances, TableStruct_RoutedHelloRpc_2eproto::offsets, - file_level_metadata_RoutedHelloRpc_2eproto, file_level_enum_descriptors_RoutedHelloRpc_2eproto, file_level_service_descriptors_RoutedHelloRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_RoutedHelloRpc_2eproto_getter() { - return &descriptor_table_RoutedHelloRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_RoutedHelloRpc_2eproto(&descriptor_table_RoutedHelloRpc_2eproto); // =================================================================== class RoutedHelloRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RoutedHelloRequest, _impl_._has_bits_); }; -RoutedHelloRequest::RoutedHelloRequest(::google::protobuf::Arena* arena) +RoutedHelloRequest::RoutedHelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RoutedHelloRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:RoutedHelloRequest) } -inline PROTOBUF_NDEBUG_INLINE RoutedHelloRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : myname_(arena, from.myname_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RoutedHelloRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::RoutedHelloRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + myname_(arena, from.myname_) {} RoutedHelloRequest::RoutedHelloRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RoutedHelloRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RoutedHelloRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RoutedHelloRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:RoutedHelloRequest) } -inline PROTOBUF_NDEBUG_INLINE RoutedHelloRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : myname_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RoutedHelloRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + myname_(arena) {} -inline void RoutedHelloRequest::SharedCtor(::_pb::Arena* arena) { +inline void RoutedHelloRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RoutedHelloRequest::~RoutedHelloRequest() { // @@protoc_insertion_point(destructor:RoutedHelloRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RoutedHelloRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.myname_.Destroy(); - _impl_.~Impl_(); +inline void RoutedHelloRequest::SharedDtor(MessageLite& self) { + RoutedHelloRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.myname_.Destroy(); + this_._impl_.~Impl_(); } -::_pbi::CachedSize* RoutedHelloRequest::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL RoutedHelloRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RoutedHelloRequest(arena); +} +constexpr auto RoutedHelloRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RoutedHelloRequest), + alignof(RoutedHelloRequest)); } -void RoutedHelloRequest::InternalSwap(RoutedHelloRequest* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto RoutedHelloRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RoutedHelloRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RoutedHelloRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RoutedHelloRequest::SharedDtor, + static_cast(&RoutedHelloRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RoutedHelloRequest, _impl_._cached_size_), + false, + }, + &RoutedHelloRequest::kDescriptorMethods, + &descriptor_table_RoutedHelloRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RoutedHelloRequest_class_data_ = + RoutedHelloRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RoutedHelloRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RoutedHelloRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RoutedHelloRequest_class_data_.tc_table); + return RoutedHelloRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 33, 2> +RoutedHelloRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RoutedHelloRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + RoutedHelloRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::RoutedHelloRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string myName = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RoutedHelloRequest, _impl_.myname_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string myName = 1; + {PROTOBUF_FIELD_OFFSET(RoutedHelloRequest, _impl_.myname_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\22\6\0\0\0\0\0\0" + "RoutedHelloRequest" + "myName" + }}, +}; +void RoutedHelloRequest::InternalSwap(RoutedHelloRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RoutedHelloRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_RoutedHelloRpc_2eproto_getter, &descriptor_table_RoutedHelloRpc_2eproto_once, - file_level_metadata_RoutedHelloRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RoutedHelloResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RoutedHelloResponse, _impl_._has_bits_); }; -RoutedHelloResponse::RoutedHelloResponse(::google::protobuf::Arena* arena) +RoutedHelloResponse::RoutedHelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RoutedHelloResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:RoutedHelloResponse) } -inline PROTOBUF_NDEBUG_INLINE RoutedHelloResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : greeting_(arena, from.greeting_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RoutedHelloResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::RoutedHelloResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + greeting_(arena, from.greeting_) {} RoutedHelloResponse::RoutedHelloResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RoutedHelloResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RoutedHelloResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RoutedHelloResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:RoutedHelloResponse) } -inline PROTOBUF_NDEBUG_INLINE RoutedHelloResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : greeting_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RoutedHelloResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + greeting_(arena) {} -inline void RoutedHelloResponse::SharedCtor(::_pb::Arena* arena) { +inline void RoutedHelloResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RoutedHelloResponse::~RoutedHelloResponse() { // @@protoc_insertion_point(destructor:RoutedHelloResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); +} +inline void RoutedHelloResponse::SharedDtor(MessageLite& self) { + RoutedHelloResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.greeting_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RoutedHelloResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RoutedHelloResponse(arena); +} +constexpr auto RoutedHelloResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RoutedHelloResponse), + alignof(RoutedHelloResponse)); } -inline void RoutedHelloResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.greeting_.Destroy(); - _impl_.~Impl_(); +constexpr auto RoutedHelloResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RoutedHelloResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RoutedHelloResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RoutedHelloResponse::SharedDtor, + static_cast(&RoutedHelloResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RoutedHelloResponse, _impl_._cached_size_), + false, + }, + &RoutedHelloResponse::kDescriptorMethods, + &descriptor_table_RoutedHelloRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RoutedHelloResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RoutedHelloResponse_class_data_ = + RoutedHelloResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RoutedHelloResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RoutedHelloResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RoutedHelloResponse_class_data_.tc_table); + return RoutedHelloResponse_class_data_.base(); } -void RoutedHelloResponse::InternalSwap(RoutedHelloResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 36, 2> +RoutedHelloResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RoutedHelloResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + RoutedHelloResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::RoutedHelloResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string greeting = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RoutedHelloResponse, _impl_.greeting_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string greeting = 1; + {PROTOBUF_FIELD_OFFSET(RoutedHelloResponse, _impl_.greeting_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\23\10\0\0\0\0\0\0" + "RoutedHelloResponse" + "greeting" + }}, +}; +void RoutedHelloResponse::InternalSwap(RoutedHelloResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RoutedHelloResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_RoutedHelloRpc_2eproto_getter, &descriptor_table_RoutedHelloRpc_2eproto_once, - file_level_metadata_RoutedHelloRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) namespace google { @@ -268,4 +445,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_RoutedHelloRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.h b/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.h index 777b0c3f..7dd7d0a2 100644 --- a/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.h +++ b/packages/streamr-proto-rpc/examples/routed-hello/proto/RoutedHelloRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: RoutedHelloRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_RoutedHelloRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_RoutedHelloRpc_2eproto_2epb_2eh +#ifndef RoutedHelloRpc_2eproto_2epb_2eh +#define RoutedHelloRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,6 +24,7 @@ #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" @@ -43,7 +38,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -52,14 +48,17 @@ class AnyMetadata; struct TableStruct_RoutedHelloRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_RoutedHelloRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_RoutedHelloRpc_2eproto; +} // extern "C" class RoutedHelloRequest; struct RoutedHelloRequestDefaultTypeInternal; extern RoutedHelloRequestDefaultTypeInternal _RoutedHelloRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RoutedHelloRequest_class_data_; class RoutedHelloResponse; struct RoutedHelloResponseDefaultTypeInternal; extern RoutedHelloResponseDefaultTypeInternal _RoutedHelloResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RoutedHelloResponse_class_data_; namespace google { namespace protobuf { } // namespace protobuf @@ -71,32 +70,32 @@ namespace protobuf { // ------------------------------------------------------------------- -class RoutedHelloResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:RoutedHelloResponse) */ { +class RoutedHelloResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:RoutedHelloResponse) */ { public: inline RoutedHelloResponse() : RoutedHelloResponse(nullptr) {} - ~RoutedHelloResponse() override; - template - explicit PROTOBUF_CONSTEXPR RoutedHelloResponse(::google::protobuf::internal::ConstantInitialized); + ~RoutedHelloResponse() PROTOBUF_FINAL; - inline RoutedHelloResponse(const RoutedHelloResponse& from) - : RoutedHelloResponse(nullptr, from) {} - RoutedHelloResponse(RoutedHelloResponse&& from) noexcept - : RoutedHelloResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RoutedHelloResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RoutedHelloResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR RoutedHelloResponse(::google::protobuf::internal::ConstantInitialized); + inline RoutedHelloResponse(const RoutedHelloResponse& from) : RoutedHelloResponse(nullptr, from) {} + inline RoutedHelloResponse(RoutedHelloResponse&& from) noexcept + : RoutedHelloResponse(nullptr, ::std::move(from)) {} inline RoutedHelloResponse& operator=(const RoutedHelloResponse& from) { CopyFrom(from); return *this; } inline RoutedHelloResponse& operator=(RoutedHelloResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -108,47 +107,35 @@ class RoutedHelloResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RoutedHelloResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_RoutedHelloResponse_default_instance_); } - static inline const RoutedHelloResponse* internal_default_instance() { - return reinterpret_cast( - &_RoutedHelloResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(RoutedHelloResponse& a, RoutedHelloResponse& b) { - a.Swap(&b); - } - inline void Swap(RoutedHelloResponse* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(RoutedHelloResponse& a, RoutedHelloResponse& b) { a.Swap(&b); } + inline void Swap(RoutedHelloResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RoutedHelloResponse* other) { + void UnsafeArenaSwap(RoutedHelloResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -156,55 +143,66 @@ class RoutedHelloResponse final : // implements Message ---------------------------------------------- - RoutedHelloResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RoutedHelloResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RoutedHelloResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "RoutedHelloResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RoutedHelloResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "RoutedHelloResponse"; } + + explicit RoutedHelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RoutedHelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RoutedHelloResponse& from); + RoutedHelloResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RoutedHelloResponse&& from) noexcept + : RoutedHelloResponse(arena) { + *this = ::std::move(from); } - protected: - explicit RoutedHelloResponse(::google::protobuf::Arena* arena); - RoutedHelloResponse(::google::protobuf::Arena* arena, const RoutedHelloResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kGreetingFieldNumber = 1, }; // string greeting = 1; void clear_greeting() ; - const std::string& greeting() const; - template + const ::std::string& greeting() const; + template void set_greeting(Arg_&& arg, Args_... args); - std::string* mutable_greeting(); - PROTOBUF_NODISCARD std::string* release_greeting(); - void set_allocated_greeting(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_greeting(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_greeting(); + void set_allocated_greeting(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_greeting() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_greeting( - const std::string& value); - std::string* _internal_mutable_greeting(); + const ::std::string& _internal_greeting() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_greeting(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_greeting(); public: // @@protoc_insertion_point(class_scope:RoutedHelloResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 36, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -213,47 +211,52 @@ class RoutedHelloResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RoutedHelloResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr greeting_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_RoutedHelloRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RoutedHelloResponse_class_data_; +// ------------------------------------------------------------------- -class RoutedHelloRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:RoutedHelloRequest) */ { +class RoutedHelloRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:RoutedHelloRequest) */ { public: inline RoutedHelloRequest() : RoutedHelloRequest(nullptr) {} - ~RoutedHelloRequest() override; - template - explicit PROTOBUF_CONSTEXPR RoutedHelloRequest(::google::protobuf::internal::ConstantInitialized); + ~RoutedHelloRequest() PROTOBUF_FINAL; - inline RoutedHelloRequest(const RoutedHelloRequest& from) - : RoutedHelloRequest(nullptr, from) {} - RoutedHelloRequest(RoutedHelloRequest&& from) noexcept - : RoutedHelloRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RoutedHelloRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RoutedHelloRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR RoutedHelloRequest(::google::protobuf::internal::ConstantInitialized); + inline RoutedHelloRequest(const RoutedHelloRequest& from) : RoutedHelloRequest(nullptr, from) {} + inline RoutedHelloRequest(RoutedHelloRequest&& from) noexcept + : RoutedHelloRequest(nullptr, ::std::move(from)) {} inline RoutedHelloRequest& operator=(const RoutedHelloRequest& from) { CopyFrom(from); return *this; } inline RoutedHelloRequest& operator=(RoutedHelloRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -265,47 +268,35 @@ class RoutedHelloRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RoutedHelloRequest& default_instance() { - return *internal_default_instance(); - } - static inline const RoutedHelloRequest* internal_default_instance() { - return reinterpret_cast( - &_RoutedHelloRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(RoutedHelloRequest& a, RoutedHelloRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RoutedHelloRequest_default_instance_); } - inline void Swap(RoutedHelloRequest* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(RoutedHelloRequest& a, RoutedHelloRequest& b) { a.Swap(&b); } + inline void Swap(RoutedHelloRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RoutedHelloRequest* other) { + void UnsafeArenaSwap(RoutedHelloRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -313,55 +304,66 @@ class RoutedHelloRequest final : // implements Message ---------------------------------------------- - RoutedHelloRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RoutedHelloRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RoutedHelloRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "RoutedHelloRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RoutedHelloRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "RoutedHelloRequest"; } + + explicit RoutedHelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RoutedHelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RoutedHelloRequest& from); + RoutedHelloRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RoutedHelloRequest&& from) noexcept + : RoutedHelloRequest(arena) { + *this = ::std::move(from); } - protected: - explicit RoutedHelloRequest(::google::protobuf::Arena* arena); - RoutedHelloRequest(::google::protobuf::Arena* arena, const RoutedHelloRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kMyNameFieldNumber = 1, }; // string myName = 1; void clear_myname() ; - const std::string& myname() const; - template + const ::std::string& myname() const; + template void set_myname(Arg_&& arg, Args_... args); - std::string* mutable_myname(); - PROTOBUF_NODISCARD std::string* release_myname(); - void set_allocated_myname(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_myname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_myname(); + void set_allocated_myname(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_myname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_myname( - const std::string& value); - std::string* _internal_mutable_myname(); + const ::std::string& _internal_myname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_myname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_myname(); public: // @@protoc_insertion_point(class_scope:RoutedHelloRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 33, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -370,21 +372,25 @@ class RoutedHelloRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RoutedHelloRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr myname_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_RoutedHelloRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull RoutedHelloRequest_class_data_; + // =================================================================== @@ -403,54 +409,66 @@ class RoutedHelloRequest final : // string myName = 1; inline void RoutedHelloRequest::clear_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.myname_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RoutedHelloRequest::myname() const +inline const ::std::string& RoutedHelloRequest::myname() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:RoutedHelloRequest.myName) return _internal_myname(); } template -inline PROTOBUF_ALWAYS_INLINE void RoutedHelloRequest::set_myname(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RoutedHelloRequest::set_myname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.myname_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:RoutedHelloRequest.myName) } -inline std::string* RoutedHelloRequest::mutable_myname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_myname(); +inline ::std::string* PROTOBUF_NONNULL RoutedHelloRequest::mutable_myname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_myname(); // @@protoc_insertion_point(field_mutable:RoutedHelloRequest.myName) return _s; } -inline const std::string& RoutedHelloRequest::_internal_myname() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RoutedHelloRequest::_internal_myname() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.myname_.Get(); } -inline void RoutedHelloRequest::_internal_set_myname(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RoutedHelloRequest::_internal_set_myname(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.myname_.Set(value, GetArena()); } -inline std::string* RoutedHelloRequest::_internal_mutable_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RoutedHelloRequest::_internal_mutable_myname() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.myname_.Mutable( GetArena()); } -inline std::string* RoutedHelloRequest::release_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RoutedHelloRequest::release_myname() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RoutedHelloRequest.myName) - return _impl_.myname_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.myname_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.myname_.Set("", GetArena()); + } + return released; } -inline void RoutedHelloRequest::set_allocated_myname(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RoutedHelloRequest::set_allocated_myname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.myname_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.myname_.IsDefault()) { - _impl_.myname_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.myname_.IsDefault()) { + _impl_.myname_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:RoutedHelloRequest.myName) } @@ -460,54 +478,66 @@ inline void RoutedHelloRequest::set_allocated_myname(std::string* value) { // string greeting = 1; inline void RoutedHelloResponse::clear_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.greeting_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RoutedHelloResponse::greeting() const +inline const ::std::string& RoutedHelloResponse::greeting() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:RoutedHelloResponse.greeting) return _internal_greeting(); } template -inline PROTOBUF_ALWAYS_INLINE void RoutedHelloResponse::set_greeting(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RoutedHelloResponse::set_greeting(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.greeting_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:RoutedHelloResponse.greeting) } -inline std::string* RoutedHelloResponse::mutable_greeting() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_greeting(); +inline ::std::string* PROTOBUF_NONNULL RoutedHelloResponse::mutable_greeting() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_greeting(); // @@protoc_insertion_point(field_mutable:RoutedHelloResponse.greeting) return _s; } -inline const std::string& RoutedHelloResponse::_internal_greeting() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RoutedHelloResponse::_internal_greeting() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.greeting_.Get(); } -inline void RoutedHelloResponse::_internal_set_greeting(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RoutedHelloResponse::_internal_set_greeting(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.greeting_.Set(value, GetArena()); } -inline std::string* RoutedHelloResponse::_internal_mutable_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RoutedHelloResponse::_internal_mutable_greeting() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.greeting_.Mutable( GetArena()); } -inline std::string* RoutedHelloResponse::release_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RoutedHelloResponse::release_greeting() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RoutedHelloResponse.greeting) - return _impl_.greeting_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.greeting_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.greeting_.Set("", GetArena()); + } + return released; } -inline void RoutedHelloResponse::set_allocated_greeting(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RoutedHelloResponse::set_allocated_greeting(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.greeting_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.greeting_.IsDefault()) { - _impl_.greeting_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.greeting_.IsDefault()) { + _impl_.greeting_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:RoutedHelloResponse.greeting) } @@ -522,4 +552,4 @@ inline void RoutedHelloResponse::set_allocated_greeting(std::string* value) { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_RoutedHelloRpc_2eproto_2epb_2eh +#endif // RoutedHelloRpc_2eproto_2epb_2eh diff --git a/packages/streamr-proto-rpc/include/streamr-proto-rpc/Errors.hpp b/packages/streamr-proto-rpc/include/streamr-proto-rpc/Errors.hpp index 8ac175c2..90b2e881 100644 --- a/packages/streamr-proto-rpc/include/streamr-proto-rpc/Errors.hpp +++ b/packages/streamr-proto-rpc/include/streamr-proto-rpc/Errors.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include namespace streamr::protorpc { diff --git a/packages/streamr-proto-rpc/include/streamr-proto-rpc/PluginCodeGenerator.hpp b/packages/streamr-proto-rpc/include/streamr-proto-rpc/PluginCodeGenerator.hpp index f0e16431..7a0d2a2e 100644 --- a/packages/streamr-proto-rpc/include/streamr-proto-rpc/PluginCodeGenerator.hpp +++ b/packages/streamr-proto-rpc/include/streamr-proto-rpc/PluginCodeGenerator.hpp @@ -61,7 +61,7 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { google::protobuf::compiler::GeneratorContext* generatorContext, std::string* /* error */) const { bool emptyIncluded = false; - const std::string& protoFilename = file->name(); + const std::string protoFilename(file->name()); const std::string protoFilenameWe = getFilenameWithoutExtension(protoFilename); const std::string headerFilename = protoFilenameWe + ".server.pb.h"; @@ -93,8 +93,8 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { for (int i = 0; i < numServices; i++) { const google::protobuf::ServiceDescriptor* service = file->service(i); - const std::string serviceFullname = service->full_name(); - const std::string& serviceName = service->name(); + const std::string serviceFullname(service->full_name()); + const std::string serviceName(service->name()); sourceSs << "template \n"; sourceSs << "class " << serviceName << " {\n"; @@ -106,14 +106,13 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { for (int j = 0; j < numMethods; j++) { const google::protobuf::MethodDescriptor* method = service->method(j); - const std::string methodFullname = method->full_name(); - const std::string& methodName = method->name(); + const std::string methodFullname(method->full_name()); + const std::string methodName(method->name()); const google::protobuf::Descriptor* methodInput = method->input_type(); - const std::string methodInputFullname = - methodInput->full_name(); - std::string methodInputName = methodInput->name(); + const std::string methodInputFullname(methodInput->full_name()); + std::string methodInputName(methodInput->name()); const google::protobuf::Descriptor* methodOutput = method->output_type(); @@ -126,9 +125,8 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { methodInputName = "google::protobuf::Empty"; } - const std::string methodOutputFullname = - methodOutput->full_name(); - std::string methodOutputName = methodOutput->name(); + const std::string methodOutputFullname(methodOutput->full_name()); + std::string methodOutputName(methodOutput->name()); if (methodOutputName == "Empty") { methodOutputName = "void"; @@ -173,7 +171,7 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { google::protobuf::compiler::GeneratorContext* generatorContext, std::string* /* error */) const { bool emptyIncluded = false; - const std::string& protoFilename = file->name(); + const std::string protoFilename(file->name()); const std::string protoFilenameWe = getFilenameWithoutExtension(protoFilename); const std::string headerFilename = protoFilenameWe + ".client.pb.h"; @@ -212,8 +210,8 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { for (int i = 0; i < numServices; i++) { const google::protobuf::ServiceDescriptor* service = file->service(i); - const std::string serviceFullname = service->full_name(); - const std::string& serviceName = service->name(); + const std::string serviceFullname(service->full_name()); + const std::string serviceName(service->name()); sourceSs << "template \n"; sourceSs << "class " << serviceName << "Client" << " {\n"; sourceSs << "private:\n"; @@ -228,14 +226,13 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { for (int j = 0; j < numMethods; j++) { const google::protobuf::MethodDescriptor* method = service->method(j); - const std::string methodFullname = method->full_name(); - const std::string& methodName = method->name(); + const std::string methodFullname(method->full_name()); + const std::string methodName(method->name()); const google::protobuf::Descriptor* methodInput = method->input_type(); - const std::string methodInputFullname = - methodInput->full_name(); - std::string methodInputName = methodInput->name(); + const std::string methodInputFullname(methodInput->full_name()); + std::string methodInputName(methodInput->name()); const google::protobuf::Descriptor* methodOutput = method->output_type(); @@ -248,9 +245,8 @@ class PluginCodeGenerator : public google::protobuf::compiler::CodeGenerator { methodInputName = "google::protobuf::Empty"; } - const std::string methodOutputFullname = - methodOutput->full_name(); - std::string methodOutputName = methodOutput->name(); + const std::string methodOutputFullname(methodOutput->full_name()); + std::string methodOutputName(methodOutput->name()); if (methodOutputName == "Empty") { methodOutputName = "void"; diff --git a/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicator.hpp b/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicator.hpp index 58545ac2..65bae6fe 100644 --- a/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicator.hpp +++ b/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicator.hpp @@ -11,7 +11,7 @@ // #include #include -#include +#include #include "RpcCommunicatorClientApi.hpp" #include "RpcCommunicatorServerApi.hpp" #include "ServerRegistry.hpp" diff --git a/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicatorClientApi.hpp b/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicatorClientApi.hpp index 929a1d54..58d36bc8 100644 --- a/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicatorClientApi.hpp +++ b/packages/streamr-proto-rpc/include/streamr-proto-rpc/RpcCommunicatorClientApi.hpp @@ -197,7 +197,8 @@ class RpcCommunicatorClientApi { try { co_return co_await folly::coro::timeout( folly::coro::detachOnCancel( - std::move(callMakingTask).scheduleOn(&mExecutor)), + folly::coro::co_withExecutor( + &mExecutor, std::move(callMakingTask))), timeoutValue); } catch (const folly::FutureTimeout& e) { SLogger::trace( @@ -262,8 +263,10 @@ class RpcCommunicatorClientApi { } }); co_return co_await folly::coro::timeout( - folly::coro::detachOnCancel(std::move(promiseContract.second)) - .scheduleOn(&mExecutor), + folly::coro::co_withExecutor( + &mExecutor, + folly::coro::detachOnCancel( + std::move(promiseContract.second))), timeoutValue); } catch (const folly::FutureTimeout& e) { SLogger::trace("notify() timed out"); diff --git a/packages/streamr-proto-rpc/proto.sh b/packages/streamr-proto-rpc/proto.sh index b3d73405..8405aa05 100755 --- a/packages/streamr-proto-rpc/proto.sh +++ b/packages/streamr-proto-rpc/proto.sh @@ -1,4 +1,6 @@ -PROTOC=../../build/vcpkg_installed/arm64-osx/tools/protobuf/protoc +# Use the protoc that matches the installed libprotobuf; triplet detected +# from the monorepo build dir (override with PROTOC=... if needed). +PROTOC=${PROTOC:-$(ls ../../build/vcpkg_installed/*/tools/protobuf/protoc 2>/dev/null | head -1)} PLUGIN=./build/protobuf-streamr-plugin # temporarily copy protos/*.proto to protos/packages/streamr-proto-rpc/protos @@ -7,17 +9,17 @@ mkdir -p protos/packages/proto-rpc/protos cp protos/*.proto protos/packages/proto-rpc/protos mkdir -p ./src/proto -${PROTOC} -I=protos --cpp_out=src/proto protos/packages/proto-rpc/protos/ProtoRpc.proto --experimental_allow_proto3_optional +${PROTOC} -I=protos --cpp_out=src/proto protos/packages/proto-rpc/protos/ProtoRpc.proto rm -rf protos/packages mkdir -p ./test/proto -${PROTOC} -I=test/protos --cpp_out=./test/proto test/protos/*.proto --experimental_allow_proto3_optional -${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./test/proto --proto_path=test/protos test/protos/*.proto --experimental_allow_proto3_optional +${PROTOC} -I=test/protos --cpp_out=./test/proto test/protos/*.proto +${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./test/proto --proto_path=test/protos test/protos/*.proto mkdir -p ./examples/hello/proto -${PROTOC} -I=examples/hello --cpp_out=./examples/hello/proto examples/hello/*.proto --experimental_allow_proto3_optional -${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./examples/hello/proto --proto_path=examples/hello examples/hello/*.proto --experimental_allow_proto3_optional +${PROTOC} -I=examples/hello --cpp_out=./examples/hello/proto examples/hello/*.proto +${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./examples/hello/proto --proto_path=examples/hello examples/hello/*.proto mkdir -p ./examples/routed-hello/proto -${PROTOC} -I=examples/routed-hello --cpp_out=./examples/routed-hello/proto examples/routed-hello/*.proto --experimental_allow_proto3_optional -${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./examples/routed-hello/proto --proto_path=examples/routed-hello examples/routed-hello/*.proto --experimental_allow_proto3_optional +${PROTOC} -I=examples/routed-hello --cpp_out=./examples/routed-hello/proto examples/routed-hello/*.proto +${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./examples/routed-hello/proto --proto_path=examples/routed-hello examples/routed-hello/*.proto diff --git a/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc b/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc index 842c2e07..b8f9719f 100644 --- a/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc +++ b/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/proto-rpc/protos/ProtoRpc.proto +// Protobuf C++ Version: 6.33.4 #include "packages/proto-rpc/protos/ProtoRpc.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" @@ -18,9 +23,16 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; namespace protorpc { - template -PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : RpcMessage_HeaderEntry_DoNotUse::MapEntry(RpcMessage_HeaderEntry_DoNotUse_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : RpcMessage_HeaderEntry_DoNotUse::MapEntry() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal { PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal() {} @@ -35,7 +47,6 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RpcMessage::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - header_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), @@ -49,11 +60,18 @@ inline constexpr RpcMessage::Impl_::Impl_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), body_{nullptr}, - errortype_{static_cast< ::protorpc::RpcErrorType >(0)} {} + errortype_{static_cast< ::protorpc::RpcErrorType >(0)}, + header_{} {} template PROTOBUF_CONSTEXPR RpcMessage::RpcMessage(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RpcMessage_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RpcMessageDefaultTypeInternal { PROTOBUF_CONSTEXPR RpcMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RpcMessageDefaultTypeInternal() {} @@ -72,7 +90,13 @@ inline constexpr Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( template PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal { PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal() {} @@ -84,71 +108,57 @@ struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal _Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_; } // namespace protorpc -static ::_pb::Metadata file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[3]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = nullptr; -const ::uint32_t TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _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(::protorpc::RpcMessage_HeaderEntry_DoNotUse, key_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, value_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _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(::protorpc::RpcMessage, _impl_.header_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errortype_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorclassname_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorcode_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errormessage_), - ~0u, - 3, - ~0u, - 4, - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _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(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), - 0, +const ::uint32_t + TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_.value_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.header_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errortype_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorclassname_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorcode_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errormessage_), + 6, + 4, + 0, + 5, + 1, + 2, + 3, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 10, -1, sizeof(::protorpc::RpcMessage_HeaderEntry_DoNotUse)}, - {12, 27, -1, sizeof(::protorpc::RpcMessage)}, - {34, 43, -1, sizeof(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::protorpc::RpcMessage_HeaderEntry_DoNotUse)}, + {7, sizeof(::protorpc::RpcMessage)}, + {24, sizeof(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::protorpc::_RpcMessage_HeaderEntry_DoNotUse_default_instance_._instance, &::protorpc::_RpcMessage_default_instance_._instance, &::protorpc::_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_._instance, }; -const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n(packages/proto-rpc/protos/ProtoRpc.pro" "to\022\010protorpc\032\033google/protobuf/empty.prot" "o\032\031google/protobuf/any.proto\"\344\002\n\nRpcMess" @@ -167,13 +177,13 @@ const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_ "UNKNOWN_RPC_METHOD\020\002\022\020\n\014CLIENT_ERROR\020\003\022\020" "\n\014SERVER_ERROR\020\004B\002H\002b\006proto3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_deps[2] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::absl::once_flag descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = { false, false, 668, @@ -186,127 +196,185 @@ const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2 schemas, file_default_instances, TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, file_level_service_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter() { - return &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto); namespace protorpc { -const ::google::protobuf::EnumDescriptor* RpcErrorType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcErrorType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto); return file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t RpcErrorType_internal_data_[] = { 327680u, 0u, }; -bool RpcErrorType_IsValid(int value) { - return 0 <= value && value <= 4; -} // =================================================================== -RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() {} -RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* arena) - : SuperType(arena) {} -::google::protobuf::Metadata RpcMessage_HeaderEntry_DoNotUse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[0]); +#if defined(PROTOBUF_CUSTOM_VTABLE) +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() + : SuperType(RpcMessage_HeaderEntry_DoNotUse_class_data_.base()) {} +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : SuperType(arena, RpcMessage_HeaderEntry_DoNotUse_class_data_.base()) {} +#else // PROTOBUF_CUSTOM_VTABLE +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() : SuperType() {} +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : SuperType(arena) {} +#endif // PROTOBUF_CUSTOM_VTABLE +inline void* PROTOBUF_NONNULL RpcMessage_HeaderEntry_DoNotUse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RpcMessage_HeaderEntry_DoNotUse(arena); +} +constexpr auto RpcMessage_HeaderEntry_DoNotUse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcMessage_HeaderEntry_DoNotUse), + alignof(RpcMessage_HeaderEntry_DoNotUse)); +} +constexpr auto RpcMessage_HeaderEntry_DoNotUse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RpcMessage_HeaderEntry_DoNotUse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcMessage_HeaderEntry_DoNotUse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcMessage_HeaderEntry_DoNotUse::SharedDtor, + static_cast(&RpcMessage_HeaderEntry_DoNotUse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_._cached_size_), + false, + }, + &RpcMessage_HeaderEntry_DoNotUse::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; } + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_ = + RpcMessage_HeaderEntry_DoNotUse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RpcMessage_HeaderEntry_DoNotUse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RpcMessage_HeaderEntry_DoNotUse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RpcMessage_HeaderEntry_DoNotUse_class_data_.tc_table); + return RpcMessage_HeaderEntry_DoNotUse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 48, 2> +RpcMessage_HeaderEntry_DoNotUse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_._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 + RpcMessage_HeaderEntry_DoNotUse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::DiscardEverythingFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::RpcMessage_HeaderEntry_DoNotUse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string value = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.value_)}}, + // string key = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string key = 1; + {PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string value = 2; + {PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.value_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\37\3\5\0\0\0\0\0" + "protorpc.RpcMessage.HeaderEntry" + "key" + "value" + }}, +}; // =================================================================== class RpcMessage::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._has_bits_); - static const ::google::protobuf::Any& body(const RpcMessage* msg); - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_errortype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_errorclassname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_errorcode(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_errormessage(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._has_bits_); }; -const ::google::protobuf::Any& RpcMessage::_Internal::body(const RpcMessage* msg) { - return *msg->_impl_.body_; -} void RpcMessage::clear_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ != nullptr) _impl_.body_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -RpcMessage::RpcMessage(::google::protobuf::Arena* arena) +RpcMessage::RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RpcMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:protorpc.RpcMessage) } -inline PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::protorpc::RpcMessage& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - header_{visibility, arena, from.header_}, requestid_(arena, from.requestid_), errorclassname_(arena, from.errorclassname_), errorcode_(arena, from.errorcode_), - errormessage_(arena, from.errormessage_) {} + errormessage_(arena, from.errormessage_), + header_{visibility, arena, from.header_} {} RpcMessage::RpcMessage( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RpcMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RpcMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RpcMessage* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.body_ = (cached_has_bits & 0x00000008u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.body_) + _impl_.body_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_) : nullptr; _impl_.errortype_ = from._impl_.errortype_; // @@protoc_insertion_point(copy_constructor:protorpc.RpcMessage) } -inline PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - header_{visibility, arena}, requestid_(arena), errorclassname_(arena), errorcode_(arena), - errormessage_(arena) {} + errormessage_(arena), + header_{visibility, arena} {} -inline void RpcMessage::SharedCtor(::_pb::Arena* arena) { +inline void RpcMessage::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, body_), 0, offsetof(Impl_, errortype_) - @@ -315,110 +383,325 @@ inline void RpcMessage::SharedCtor(::_pb::Arena* arena) { } RpcMessage::~RpcMessage() { // @@protoc_insertion_point(destructor:protorpc.RpcMessage) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RpcMessage::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.errorclassname_.Destroy(); - _impl_.errorcode_.Destroy(); - _impl_.errormessage_.Destroy(); - delete _impl_.body_; - _impl_.~Impl_(); +inline void RpcMessage::SharedDtor(MessageLite& self) { + RpcMessage& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.errorclassname_.Destroy(); + this_._impl_.errorcode_.Destroy(); + this_._impl_.errormessage_.Destroy(); + delete this_._impl_.body_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RpcMessage::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RpcMessage(arena); } +constexpr auto RpcMessage::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.header_) + + decltype(RpcMessage::_impl_.header_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(RpcMessage), alignof(RpcMessage), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RpcMessage::PlacementNew_, + sizeof(RpcMessage), + alignof(RpcMessage)); + } +} +constexpr auto RpcMessage::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RpcMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcMessage::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcMessage::SharedDtor, + static_cast(&RpcMessage::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._cached_size_), + false, + }, + &RpcMessage::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_ = + RpcMessage::InternalGenerateClassData_(); -::_pbi::CachedSize* RpcMessage::AccessCachedSize() const { - return &_impl_._cached_size_; +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RpcMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RpcMessage_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RpcMessage_class_data_.tc_table); + return RpcMessage_class_data_.base(); } -void RpcMessage::InternalSwap(RpcMessage* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 2, 78, 2> +RpcMessage::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcMessage, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RpcMessage_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::RpcMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + // .google.protobuf.Any body = 2; + {::_pbi::TcParser::FastMtS1, + {18, 4, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.body_)}}, + // string requestId = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.requestid_)}}, + // optional .protorpc.RpcErrorType errorType = 4; + {::_pbi::TcParser::FastV32S1, + {32, 5, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errortype_)}}, + // optional string errorClassName = 5; + {::_pbi::TcParser::FastUS1, + {42, 1, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorclassname_)}}, + // optional string errorCode = 6; + {::_pbi::TcParser::FastUS1, + {50, 2, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorcode_)}}, + // optional string errorMessage = 7; + {::_pbi::TcParser::FastUS1, + {58, 3, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errormessage_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // map header = 1; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.header_), _Internal::kHasBitsOffset + 6, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMap)}, + // .google.protobuf.Any body = 2; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.body_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 3; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .protorpc.RpcErrorType errorType = 4; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errortype_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // optional string errorClassName = 5; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorclassname_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string errorCode = 6; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorcode_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string errorMessage = 7; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errormessage_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetMapAuxInfo( + 1, 0, 9, 9, 0)}, + }}, + {{ + "\23\6\0\11\0\16\11\14" + "protorpc.RpcMessage" + "header" + "requestId" + "errorClassName" + "errorCode" + "errorMessage" + }}, +}; +void RpcMessage::InternalSwap(RpcMessage* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RpcMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Mnfo2uhnf92hvqi2nviouq2hv9puhq::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_); - static const ::google::protobuf::Empty& empty(const Mnfo2uhnf92hvqi2nviouq2hv9puhq* msg); - static void set_has_empty(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_); }; -const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::_Internal::empty(const Mnfo2uhnf92hvqi2nviouq2hv9puhq* msg) { - return *msg->_impl_.empty_; -} void Mnfo2uhnf92hvqi2nviouq2hv9puhq::clear_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.empty_ != nullptr) _impl_.empty_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena) +Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) } -inline PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.empty_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Empty>(arena, *from._impl_.empty_) + _impl_.empty_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.empty_) : nullptr; // @@protoc_insertion_point(copy_constructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) } -inline PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedCtor(::_pb::Arena* arena) { +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.empty_ = {}; } Mnfo2uhnf92hvqi2nviouq2hv9puhq::~Mnfo2uhnf92hvqi2nviouq2hv9puhq() { // @@protoc_insertion_point(destructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - delete _impl_.empty_; - _impl_.~Impl_(); +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor(MessageLite& self) { + Mnfo2uhnf92hvqi2nviouq2hv9puhq& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.empty_; + this_._impl_.~Impl_(); } -::_pbi::CachedSize* Mnfo2uhnf92hvqi2nviouq2hv9puhq::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) Mnfo2uhnf92hvqi2nviouq2hv9puhq(arena); +} +constexpr auto Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Mnfo2uhnf92hvqi2nviouq2hv9puhq), + alignof(Mnfo2uhnf92hvqi2nviouq2hv9puhq)); } -void Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor, + static_cast(&Mnfo2uhnf92hvqi2nviouq2hv9puhq::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._cached_size_), + false, + }, + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_ = + Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +Mnfo2uhnf92hvqi2nviouq2hv9puhq::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.tc_table); + return Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +Mnfo2uhnf92hvqi2nviouq2hv9puhq::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _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), + Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .google.protobuf.Empty empty = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .google.protobuf.Empty empty = 1; + {PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Empty>()}, + }}, + {{ + }}, +}; +void Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata Mnfo2uhnf92hvqi2nviouq2hv9puhq::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace protorpc @@ -427,4 +710,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h b/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h index 97869d4b..a3861406 100644 --- a/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h +++ b/packages/streamr-proto-rpc/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/proto-rpc/protos/ProtoRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#ifndef packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#define packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,11 +24,13 @@ #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/map.h" // IWYU pragma: export +#include "google/protobuf/map_type_handler.h" // IWYU pragma: export #include "google/protobuf/map_entry.h" -#include "google/protobuf/map_field_inl.h" +#include "google/protobuf/map_field.h" #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" @@ -49,7 +45,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -58,21 +55,30 @@ class AnyMetadata; struct TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; +} // extern "C" namespace protorpc { +enum RpcErrorType : int; +extern const uint32_t RpcErrorType_internal_data_[]; class Mnfo2uhnf92hvqi2nviouq2hv9puhq; struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal; extern Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal _Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_; class RpcMessage; struct RpcMessageDefaultTypeInternal; extern RpcMessageDefaultTypeInternal _RpcMessage_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_; class RpcMessage_HeaderEntry_DoNotUse; struct RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal; extern RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal _RpcMessage_HeaderEntry_DoNotUse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_; } // namespace protorpc namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::protorpc::RpcErrorType_internal_data_> + internal::EnumTraitsImpl::value<::protorpc::RpcErrorType>; } // namespace protobuf } // namespace google @@ -84,34 +90,37 @@ enum RpcErrorType : int { CLIENT_ERROR = 3, SERVER_ERROR = 4, RpcErrorType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RpcErrorType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RpcErrorType_IsValid(int value); extern const uint32_t RpcErrorType_internal_data_[]; -constexpr RpcErrorType RpcErrorType_MIN = static_cast(0); -constexpr RpcErrorType RpcErrorType_MAX = static_cast(4); -constexpr int RpcErrorType_ARRAYSIZE = 4 + 1; -const ::google::protobuf::EnumDescriptor* -RpcErrorType_descriptor(); +inline constexpr RpcErrorType RpcErrorType_MIN = + static_cast(0); +inline constexpr RpcErrorType RpcErrorType_MAX = + static_cast(4); +inline bool RpcErrorType_IsValid(int value) { + return 0 <= value && value <= 4; +} +inline constexpr int RpcErrorType_ARRAYSIZE = 4 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcErrorType_descriptor(); template -const std::string& RpcErrorType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RpcErrorType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RpcErrorType_Name()."); return RpcErrorType_Name(static_cast(value)); } template <> -inline const std::string& RpcErrorType_Name(RpcErrorType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RpcErrorType_Name(RpcErrorType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RpcErrorType_Parse(absl::string_view name, RpcErrorType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RpcErrorType_descriptor(), name, value); +inline bool RpcErrorType_Parse( + ::absl::string_view name, RpcErrorType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RpcErrorType_descriptor(), name, + value); } // =================================================================== @@ -120,61 +129,70 @@ inline bool RpcErrorType_Parse(absl::string_view name, RpcErrorType* value) { // ------------------------------------------------------------------- class RpcMessage_HeaderEntry_DoNotUse final - : public ::google::protobuf::internal::MapEntry< - RpcMessage_HeaderEntry_DoNotUse, std::string, std::string, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING> { + : public ::google::protobuf::internal::MapEntry<::std::string, ::std::string, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING> { public: - using SuperType = ::google::protobuf::internal::MapEntry< - RpcMessage_HeaderEntry_DoNotUse, std::string, std::string, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING>; + using SuperType = + ::google::protobuf::internal::MapEntry<::std::string, ::std::string, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING>; RpcMessage_HeaderEntry_DoNotUse(); template - explicit PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse( - ::google::protobuf::internal::ConstantInitialized); - explicit RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* arena); - static const RpcMessage_HeaderEntry_DoNotUse* internal_default_instance() { - return reinterpret_cast( - &_RpcMessage_HeaderEntry_DoNotUse_default_instance_); + explicit PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::internal::ConstantInitialized); + explicit RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr const void* PROTOBUF_NONNULL internal_default_instance() { + return &_RpcMessage_HeaderEntry_DoNotUse_default_instance_; } - static bool ValidateKey(std::string* s) { - return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "protorpc.RpcMessage.HeaderEntry.key"); - } - static bool ValidateValue(std::string* s) { - return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "protorpc.RpcMessage.HeaderEntry.value"); - } - ::google::protobuf::Metadata GetMetadata() const final; + + + static constexpr auto InternalGenerateClassData_(); + + private: + friend class ::google::protobuf::MessageLite; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 48, + 2> + _table_; + + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); }; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_; // ------------------------------------------------------------------- -class RpcMessage final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protorpc.RpcMessage) */ { +class RpcMessage final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:protorpc.RpcMessage) */ { public: inline RpcMessage() : RpcMessage(nullptr) {} - ~RpcMessage() override; - template - explicit PROTOBUF_CONSTEXPR RpcMessage(::google::protobuf::internal::ConstantInitialized); + ~RpcMessage() PROTOBUF_FINAL; - inline RpcMessage(const RpcMessage& from) - : RpcMessage(nullptr, from) {} - RpcMessage(RpcMessage&& from) noexcept - : RpcMessage() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcMessage)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RpcMessage(::google::protobuf::internal::ConstantInitialized); + + inline RpcMessage(const RpcMessage& from) : RpcMessage(nullptr, from) {} + inline RpcMessage(RpcMessage&& from) noexcept + : RpcMessage(nullptr, ::std::move(from)) {} inline RpcMessage& operator=(const RpcMessage& from) { CopyFrom(from); return *this; } inline RpcMessage& operator=(RpcMessage&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -186,47 +204,35 @@ class RpcMessage final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RpcMessage& default_instance() { - return *internal_default_instance(); - } - static inline const RpcMessage* internal_default_instance() { - return reinterpret_cast( - &_RpcMessage_default_instance_); + return *reinterpret_cast( + &_RpcMessage_default_instance_); } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(RpcMessage& a, RpcMessage& b) { - a.Swap(&b); - } - inline void Swap(RpcMessage* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(RpcMessage& a, RpcMessage& b) { a.Swap(&b); } + inline void Swap(RpcMessage* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RpcMessage* other) { + void UnsafeArenaSwap(RpcMessage* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -234,138 +240,125 @@ class RpcMessage final : // implements Message ---------------------------------------------- - RpcMessage* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RpcMessage* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RpcMessage* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "protorpc.RpcMessage"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcMessage* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "protorpc.RpcMessage"; } + + explicit RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RpcMessage& from); + RpcMessage( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RpcMessage&& from) noexcept + : RpcMessage(arena) { + *this = ::std::move(from); } - protected: - explicit RpcMessage(::google::protobuf::Arena* arena); - RpcMessage(::google::protobuf::Arena* arena, const RpcMessage& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- - // accessors ------------------------------------------------------- - enum : int { - kHeaderFieldNumber = 1, kRequestIdFieldNumber = 3, kErrorClassNameFieldNumber = 5, kErrorCodeFieldNumber = 6, kErrorMessageFieldNumber = 7, kBodyFieldNumber = 2, kErrorTypeFieldNumber = 4, + kHeaderFieldNumber = 1, }; - // map header = 1; - int header_size() const; - private: - int _internal_header_size() const; - - public: - void clear_header() ; - const ::google::protobuf::Map& header() const; - ::google::protobuf::Map* mutable_header(); - - private: - const ::google::protobuf::Map& _internal_header() const; - ::google::protobuf::Map* _internal_mutable_header(); - - public: // string requestId = 3; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional string errorClassName = 5; bool has_errorclassname() const; void clear_errorclassname() ; - const std::string& errorclassname() const; - template + const ::std::string& errorclassname() const; + template void set_errorclassname(Arg_&& arg, Args_... args); - std::string* mutable_errorclassname(); - PROTOBUF_NODISCARD std::string* release_errorclassname(); - void set_allocated_errorclassname(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errorclassname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errorclassname(); + void set_allocated_errorclassname(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errorclassname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errorclassname( - const std::string& value); - std::string* _internal_mutable_errorclassname(); + const ::std::string& _internal_errorclassname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errorclassname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errorclassname(); public: // optional string errorCode = 6; bool has_errorcode() const; void clear_errorcode() ; - const std::string& errorcode() const; - template + const ::std::string& errorcode() const; + template void set_errorcode(Arg_&& arg, Args_... args); - std::string* mutable_errorcode(); - PROTOBUF_NODISCARD std::string* release_errorcode(); - void set_allocated_errorcode(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errorcode(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errorcode(); + void set_allocated_errorcode(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errorcode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errorcode( - const std::string& value); - std::string* _internal_mutable_errorcode(); + const ::std::string& _internal_errorcode() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errorcode(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errorcode(); public: // optional string errorMessage = 7; bool has_errormessage() const; void clear_errormessage() ; - const std::string& errormessage() const; - template + const ::std::string& errormessage() const; + template void set_errormessage(Arg_&& arg, Args_... args); - std::string* mutable_errormessage(); - PROTOBUF_NODISCARD std::string* release_errormessage(); - void set_allocated_errormessage(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errormessage(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errormessage(); + void set_allocated_errormessage(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errormessage() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errormessage( - const std::string& value); - std::string* _internal_mutable_errormessage(); + const ::std::string& _internal_errormessage() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errormessage(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errormessage(); public: // .google.protobuf.Any body = 2; bool has_body() const; void clear_body() ; const ::google::protobuf::Any& body() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_body(); - ::google::protobuf::Any* mutable_body(); - void set_allocated_body(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_body(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_body(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_body(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_body(); + void set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_body(); private: const ::google::protobuf::Any& _internal_body() const; - ::google::protobuf::Any* _internal_mutable_body(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_body(); public: // optional .protorpc.RpcErrorType errorType = 4; @@ -378,10 +371,30 @@ class RpcMessage final : ::protorpc::RpcErrorType _internal_errortype() const; void _internal_set_errortype(::protorpc::RpcErrorType value); + public: + // map header = 1; + int header_size() const; + private: + int _internal_header_size() const; + + public: + void clear_header() ; + const ::google::protobuf::Map<::std::string, ::std::string>& header() const; + ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL mutable_header(); + + private: + const ::google::protobuf::Map<::std::string, ::std::string>& _internal_header() const; + ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL _internal_mutable_header(); + public: // @@protoc_insertion_point(class_scope:protorpc.RpcMessage) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 2, 78, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -390,57 +403,61 @@ class RpcMessage final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RpcMessage& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::MapField - header_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr errorclassname_; ::google::protobuf::internal::ArenaStringPtr errorcode_; ::google::protobuf::internal::ArenaStringPtr errormessage_; - ::google::protobuf::Any* body_; + ::google::protobuf::Any* PROTOBUF_NULLABLE body_; int errortype_; + ::google::protobuf::internal::MapField + header_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_; +// ------------------------------------------------------------------- -class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) */ { +class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) */ { public: inline Mnfo2uhnf92hvqi2nviouq2hv9puhq() : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr) {} - ~Mnfo2uhnf92hvqi2nviouq2hv9puhq() override; - template - explicit PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::internal::ConstantInitialized); + ~Mnfo2uhnf92hvqi2nviouq2hv9puhq() PROTOBUF_FINAL; - inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) - : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, from) {} - Mnfo2uhnf92hvqi2nviouq2hv9puhq(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept - : Mnfo2uhnf92hvqi2nviouq2hv9puhq() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Mnfo2uhnf92hvqi2nviouq2hv9puhq)); } +#endif + template + explicit PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::internal::ConstantInitialized); + + inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, from) {} + inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept + : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, ::std::move(from)) {} inline Mnfo2uhnf92hvqi2nviouq2hv9puhq& operator=(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) { CopyFrom(from); return *this; } inline Mnfo2uhnf92hvqi2nviouq2hv9puhq& operator=(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -452,47 +469,35 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const Mnfo2uhnf92hvqi2nviouq2hv9puhq& default_instance() { - return *internal_default_instance(); - } - static inline const Mnfo2uhnf92hvqi2nviouq2hv9puhq* internal_default_instance() { - return reinterpret_cast( - &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq& a, Mnfo2uhnf92hvqi2nviouq2hv9puhq& b) { - a.Swap(&b); + return *reinterpret_cast( + &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_); } - inline void Swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq& a, Mnfo2uhnf92hvqi2nviouq2hv9puhq& b) { a.Swap(&b); } + inline void Swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other) { + void UnsafeArenaSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -500,33 +505,40 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : // implements Message ---------------------------------------------- - Mnfo2uhnf92hvqi2nviouq2hv9puhq* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq"; } + + explicit Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from); + Mnfo2uhnf92hvqi2nviouq2hv9puhq( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept + : Mnfo2uhnf92hvqi2nviouq2hv9puhq(arena) { + *this = ::std::move(from); } - protected: - explicit Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena); - Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEmptyFieldNumber = 1, }; @@ -534,20 +546,25 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : bool has_empty() const; void clear_empty() ; const ::google::protobuf::Empty& empty() const; - PROTOBUF_NODISCARD ::google::protobuf::Empty* release_empty(); - ::google::protobuf::Empty* mutable_empty(); - void set_allocated_empty(::google::protobuf::Empty* value); - void unsafe_arena_set_allocated_empty(::google::protobuf::Empty* value); - ::google::protobuf::Empty* unsafe_arena_release_empty(); + [[nodiscard]] ::google::protobuf::Empty* PROTOBUF_NULLABLE release_empty(); + ::google::protobuf::Empty* PROTOBUF_NONNULL mutable_empty(); + void set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value); + ::google::protobuf::Empty* PROTOBUF_NULLABLE unsafe_arena_release_empty(); private: const ::google::protobuf::Empty& _internal_empty() const; - ::google::protobuf::Empty* _internal_mutable_empty(); + ::google::protobuf::Empty* PROTOBUF_NONNULL _internal_mutable_empty(); public: // @@protoc_insertion_point(class_scope:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) 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; @@ -556,22 +573,25 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::Empty* empty_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::Empty* PROTOBUF_NULLABLE empty_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_; + // =================================================================== @@ -598,34 +618,38 @@ inline int RpcMessage::header_size() const { return _internal_header_size(); } inline void RpcMessage::clear_header() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000040U); } -inline const ::google::protobuf::Map& RpcMessage::_internal_header() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::google::protobuf::Map<::std::string, ::std::string>& RpcMessage::_internal_header() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.header_.GetMap(); } -inline const ::google::protobuf::Map& RpcMessage::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::Map<::std::string, ::std::string>& RpcMessage::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_map:protorpc.RpcMessage.header) return _internal_header(); } -inline ::google::protobuf::Map* RpcMessage::_internal_mutable_header() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL RpcMessage::_internal_mutable_header() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.header_.MutableMap(); } -inline ::google::protobuf::Map* RpcMessage::mutable_header() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL RpcMessage::mutable_header() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_mutable_map:protorpc.RpcMessage.header) return _internal_mutable_header(); } // .google.protobuf.Any body = 2; inline bool RpcMessage::has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); return value; } inline const ::google::protobuf::Any& RpcMessage::_internal_body() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.body_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -633,76 +657,78 @@ inline const ::google::protobuf::Any& RpcMessage::body() const ABSL_ATTRIBUTE_LI // @@protoc_insertion_point(field_get:protorpc.RpcMessage.body) return _internal_body(); } -inline void RpcMessage::unsafe_arena_set_allocated_body(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::unsafe_arena_set_allocated_body( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protorpc.RpcMessage.body) } -inline ::google::protobuf::Any* RpcMessage::release_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE RpcMessage::release_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* released = _impl_.body_; _impl_.body_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* RpcMessage::unsafe_arena_release_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE RpcMessage::unsafe_arena_release_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.body) - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* temp = _impl_.body_; _impl_.body_ = nullptr; return temp; } -inline ::google::protobuf::Any* RpcMessage::_internal_mutable_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000008u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL RpcMessage::_internal_mutable_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.body_; } -inline ::google::protobuf::Any* RpcMessage::mutable_body() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL RpcMessage::mutable_body() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* _msg = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.body) return _msg; } -inline void RpcMessage::set_allocated_body(::google::protobuf::Any* value) { +inline void RpcMessage::set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -711,66 +737,79 @@ inline void RpcMessage::set_allocated_body(::google::protobuf::Any* value) { // string requestId = 3; inline void RpcMessage::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RpcMessage::requestid() const +inline const ::std::string& RpcMessage::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.requestId) } -inline std::string* RpcMessage::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.requestId) return _s; } -inline const std::string& RpcMessage::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RpcMessage::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RpcMessage::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RpcMessage::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.requestId) } // optional .protorpc.RpcErrorType errorType = 4; inline bool RpcMessage::has_errortype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); return value; } inline void RpcMessage::clear_errortype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errortype_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline ::protorpc::RpcErrorType RpcMessage::errortype() const { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorType) @@ -778,228 +817,222 @@ inline ::protorpc::RpcErrorType RpcMessage::errortype() const { } inline void RpcMessage::set_errortype(::protorpc::RpcErrorType value) { _internal_set_errortype(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorType) } inline ::protorpc::RpcErrorType RpcMessage::_internal_errortype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::protorpc::RpcErrorType>(_impl_.errortype_); } inline void RpcMessage::_internal_set_errortype(::protorpc::RpcErrorType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000010u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errortype_ = value; } // optional string errorClassName = 5; inline bool RpcMessage::has_errorclassname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void RpcMessage::clear_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorclassname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RpcMessage::errorclassname() const +inline const ::std::string& RpcMessage::errorclassname() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorClassName) return _internal_errorclassname(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorclassname(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorclassname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.errorclassname_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorClassName) } -inline std::string* RpcMessage::mutable_errorclassname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errorclassname(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errorclassname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_errorclassname(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorClassName) return _s; } -inline const std::string& RpcMessage::_internal_errorclassname() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errorclassname() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errorclassname_.Get(); } -inline void RpcMessage::_internal_set_errorclassname(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void RpcMessage::_internal_set_errorclassname(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorclassname_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errorclassname() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errorclassname_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errorclassname() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorClassName) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); auto* released = _impl_.errorclassname_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errorclassname_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errorclassname_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errorclassname(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errorclassname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.errorclassname_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errorclassname_.IsDefault()) { - _impl_.errorclassname_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errorclassname_.IsDefault()) { + _impl_.errorclassname_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorClassName) } // optional string errorCode = 6; inline bool RpcMessage::has_errorcode() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void RpcMessage::clear_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorcode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& RpcMessage::errorcode() const +inline const ::std::string& RpcMessage::errorcode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorCode) return _internal_errorcode(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorcode(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorcode(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.errorcode_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorCode) } -inline std::string* RpcMessage::mutable_errorcode() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errorcode(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errorcode() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_errorcode(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorCode) return _s; } -inline const std::string& RpcMessage::_internal_errorcode() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errorcode() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errorcode_.Get(); } -inline void RpcMessage::_internal_set_errorcode(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline void RpcMessage::_internal_set_errorcode(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorcode_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errorcode() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errorcode_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errorcode() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorCode) - if ((_impl_._has_bits_[0] & 0x00000002u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); auto* released = _impl_.errorcode_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errorcode_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errorcode_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errorcode(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errorcode(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.errorcode_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errorcode_.IsDefault()) { - _impl_.errorcode_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errorcode_.IsDefault()) { + _impl_.errorcode_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorCode) } // optional string errorMessage = 7; inline bool RpcMessage::has_errormessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); return value; } inline void RpcMessage::clear_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errormessage_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& RpcMessage::errormessage() const +inline const ::std::string& RpcMessage::errormessage() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorMessage) return _internal_errormessage(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errormessage(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errormessage(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.errormessage_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorMessage) } -inline std::string* RpcMessage::mutable_errormessage() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errormessage(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errormessage() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_errormessage(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorMessage) return _s; } -inline const std::string& RpcMessage::_internal_errormessage() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errormessage() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errormessage_.Get(); } -inline void RpcMessage::_internal_set_errormessage(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline void RpcMessage::_internal_set_errormessage(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errormessage_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errormessage() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errormessage_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errormessage() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorMessage) - if ((_impl_._has_bits_[0] & 0x00000004u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); auto* released = _impl_.errormessage_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errormessage_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errormessage_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errormessage(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errormessage(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.errormessage_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errormessage_.IsDefault()) { - _impl_.errormessage_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errormessage_.IsDefault()) { + _impl_.errormessage_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorMessage) } @@ -1009,12 +1042,12 @@ inline void RpcMessage::set_allocated_errormessage(std::string* value) { // .google.protobuf.Empty empty = 1; inline bool Mnfo2uhnf92hvqi2nviouq2hv9puhq::has_empty() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); PROTOBUF_ASSUME(!value || _impl_.empty_ != nullptr); return value; } inline const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_empty() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Empty* p = _impl_.empty_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Empty_default_instance_); } @@ -1022,76 +1055,78 @@ inline const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::empty() // @@protoc_insertion_point(field_get:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) return _internal_empty(); } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_set_allocated_empty(::google::protobuf::Empty* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_set_allocated_empty( + ::google::protobuf::Empty* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.empty_); } _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::release_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Empty* PROTOBUF_NULLABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq::release_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* released = _impl_.empty_; _impl_.empty_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_release_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Empty* PROTOBUF_NULLABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_release_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* temp = _impl_.empty_; _impl_.empty_ = nullptr; return temp; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_mutable_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Empty* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_mutable_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.empty_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Empty>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Empty>(GetArena()); _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(p); } return _impl_.empty_; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::mutable_empty() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Empty* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::mutable_empty() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* _msg = _internal_mutable_empty(); // @@protoc_insertion_point(field_mutable:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) return _msg; } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::set_allocated_empty(::google::protobuf::Empty* value) { +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.empty_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(value); @@ -1112,7 +1147,7 @@ namespace protobuf { template <> struct is_proto_enum<::protorpc::RpcErrorType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::protorpc::RpcErrorType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::protorpc::RpcErrorType>() { return ::protorpc::RpcErrorType_descriptor(); } @@ -1123,4 +1158,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::protorpc::RpcErrorType>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#endif // packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh diff --git a/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.cc b/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.cc index 13ea014c..21006f1f 100644 --- a/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.cc +++ b/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: HelloRpc.proto +// Protobuf C++ Version: 6.33.4 #include "HelloRpc.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" @@ -18,17 +23,24 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; inline constexpr HelloResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : greeting_( + : _cached_size_{0}, + greeting_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR HelloResponse::HelloResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HelloResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HelloResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR HelloResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HelloResponseDefaultTypeInternal() {} @@ -42,14 +54,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr HelloRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : myname_( + : _cached_size_{0}, + myname_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR HelloRequest::HelloRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HelloRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HelloRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR HelloRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HelloRequestDefaultTypeInternal() {} @@ -60,51 +78,43 @@ struct HelloRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HelloRequestDefaultTypeInternal _HelloRequest_default_instance_; -static ::_pb::Metadata file_level_metadata_HelloRpc_2eproto[2]; -static constexpr const ::_pb::EnumDescriptor** +static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_enum_descriptors_HelloRpc_2eproto = nullptr; -static constexpr const ::_pb::ServiceDescriptor** +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_HelloRpc_2eproto = nullptr; -const ::uint32_t TableStruct_HelloRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::HelloRequest, _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(::HelloRequest, _impl_.myname_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::HelloResponse, _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(::HelloResponse, _impl_.greeting_), +const ::uint32_t + TableStruct_HelloRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::HelloRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::HelloRequest, _impl_.myname_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::HelloResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::HelloResponse, _impl_.greeting_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, -1, -1, sizeof(::HelloRequest)}, - {9, -1, -1, sizeof(::HelloResponse)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::HelloRequest)}, + {5, sizeof(::HelloResponse)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::_HelloRequest_default_instance_._instance, &::_HelloResponse_default_instance_._instance, }; -const char descriptor_table_protodef_HelloRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_HelloRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n\016HelloRpc.proto\"\036\n\014HelloRequest\022\016\n\006myNa" "me\030\001 \001(\t\"!\n\rHelloResponse\022\020\n\010greeting\030\001 " "\001(\t2<\n\017HelloRpcService\022)\n\010sayHello\022\r.Hel" "loRequest\032\016.HelloResponseB\002H\002b\006proto3" }; static ::absl::once_flag descriptor_table_HelloRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_HelloRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_HelloRpc_2eproto = { false, false, 157, @@ -117,149 +127,316 @@ const ::_pbi::DescriptorTable descriptor_table_HelloRpc_2eproto = { schemas, file_default_instances, TableStruct_HelloRpc_2eproto::offsets, - file_level_metadata_HelloRpc_2eproto, file_level_enum_descriptors_HelloRpc_2eproto, file_level_service_descriptors_HelloRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_HelloRpc_2eproto_getter() { - return &descriptor_table_HelloRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_HelloRpc_2eproto(&descriptor_table_HelloRpc_2eproto); // =================================================================== class HelloRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_._has_bits_); }; -HelloRequest::HelloRequest(::google::protobuf::Arena* arena) +HelloRequest::HelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:HelloRequest) } -inline PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : myname_(arena, from.myname_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::HelloRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + myname_(arena, from.myname_) {} HelloRequest::HelloRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HelloRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:HelloRequest) } -inline PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : myname_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + myname_(arena) {} -inline void HelloRequest::SharedCtor(::_pb::Arena* arena) { +inline void HelloRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } HelloRequest::~HelloRequest() { // @@protoc_insertion_point(destructor:HelloRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void HelloRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.myname_.Destroy(); - _impl_.~Impl_(); +inline void HelloRequest::SharedDtor(MessageLite& self) { + HelloRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.myname_.Destroy(); + this_._impl_.~Impl_(); } -::_pbi::CachedSize* HelloRequest::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL HelloRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HelloRequest(arena); +} +constexpr auto HelloRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HelloRequest), + alignof(HelloRequest)); } -void HelloRequest::InternalSwap(HelloRequest* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto HelloRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HelloRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HelloRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HelloRequest::SharedDtor, + static_cast(&HelloRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_._cached_size_), + false, + }, + &HelloRequest::kDescriptorMethods, + &descriptor_table_HelloRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HelloRequest_class_data_ = + HelloRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HelloRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HelloRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HelloRequest_class_data_.tc_table); + return HelloRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 27, 2> +HelloRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HelloRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + HelloRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::HelloRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string myName = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_.myname_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string myName = 1; + {PROTOBUF_FIELD_OFFSET(HelloRequest, _impl_.myname_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\14\6\0\0\0\0\0\0" + "HelloRequest" + "myName" + }}, +}; +void HelloRequest::InternalSwap(HelloRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HelloRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_HelloRpc_2eproto_getter, &descriptor_table_HelloRpc_2eproto_once, - file_level_metadata_HelloRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HelloResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_._has_bits_); }; -HelloResponse::HelloResponse(::google::protobuf::Arena* arena) +HelloResponse::HelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:HelloResponse) } -inline PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : greeting_(arena, from.greeting_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::HelloResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + greeting_(arena, from.greeting_) {} HelloResponse::HelloResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HelloResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HelloResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:HelloResponse) } -inline PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : greeting_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE HelloResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + greeting_(arena) {} -inline void HelloResponse::SharedCtor(::_pb::Arena* arena) { +inline void HelloResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } HelloResponse::~HelloResponse() { // @@protoc_insertion_point(destructor:HelloResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); +} +inline void HelloResponse::SharedDtor(MessageLite& self) { + HelloResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.greeting_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL HelloResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HelloResponse(arena); +} +constexpr auto HelloResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HelloResponse), + alignof(HelloResponse)); } -inline void HelloResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.greeting_.Destroy(); - _impl_.~Impl_(); +constexpr auto HelloResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HelloResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HelloResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HelloResponse::SharedDtor, + static_cast(&HelloResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_._cached_size_), + false, + }, + &HelloResponse::kDescriptorMethods, + &descriptor_table_HelloRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* HelloResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HelloResponse_class_data_ = + HelloResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HelloResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HelloResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HelloResponse_class_data_.tc_table); + return HelloResponse_class_data_.base(); } -void HelloResponse::InternalSwap(HelloResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 30, 2> +HelloResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HelloResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + HelloResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::HelloResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string greeting = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_.greeting_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string greeting = 1; + {PROTOBUF_FIELD_OFFSET(HelloResponse, _impl_.greeting_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\15\10\0\0\0\0\0\0" + "HelloResponse" + "greeting" + }}, +}; +void HelloResponse::InternalSwap(HelloResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HelloResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_HelloRpc_2eproto_getter, &descriptor_table_HelloRpc_2eproto_once, - file_level_metadata_HelloRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) namespace google { @@ -267,4 +444,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_HelloRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.h b/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.h index 894d25a3..00b666ef 100644 --- a/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.h +++ b/packages/streamr-proto-rpc/test/proto/HelloRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: HelloRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_HelloRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_HelloRpc_2eproto_2epb_2eh +#ifndef HelloRpc_2eproto_2epb_2eh +#define HelloRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,6 +24,7 @@ #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" @@ -43,7 +38,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -52,14 +48,17 @@ class AnyMetadata; struct TableStruct_HelloRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_HelloRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_HelloRpc_2eproto; +} // extern "C" class HelloRequest; struct HelloRequestDefaultTypeInternal; extern HelloRequestDefaultTypeInternal _HelloRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HelloRequest_class_data_; class HelloResponse; struct HelloResponseDefaultTypeInternal; extern HelloResponseDefaultTypeInternal _HelloResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HelloResponse_class_data_; namespace google { namespace protobuf { } // namespace protobuf @@ -71,32 +70,32 @@ namespace protobuf { // ------------------------------------------------------------------- -class HelloResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:HelloResponse) */ { +class HelloResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:HelloResponse) */ { public: inline HelloResponse() : HelloResponse(nullptr) {} - ~HelloResponse() override; - template - explicit PROTOBUF_CONSTEXPR HelloResponse(::google::protobuf::internal::ConstantInitialized); + ~HelloResponse() PROTOBUF_FINAL; - inline HelloResponse(const HelloResponse& from) - : HelloResponse(nullptr, from) {} - HelloResponse(HelloResponse&& from) noexcept - : HelloResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HelloResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HelloResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HelloResponse(::google::protobuf::internal::ConstantInitialized); + inline HelloResponse(const HelloResponse& from) : HelloResponse(nullptr, from) {} + inline HelloResponse(HelloResponse&& from) noexcept + : HelloResponse(nullptr, ::std::move(from)) {} inline HelloResponse& operator=(const HelloResponse& from) { CopyFrom(from); return *this; } inline HelloResponse& operator=(HelloResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -108,47 +107,35 @@ class HelloResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HelloResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_HelloResponse_default_instance_); } - static inline const HelloResponse* internal_default_instance() { - return reinterpret_cast( - &_HelloResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(HelloResponse& a, HelloResponse& b) { - a.Swap(&b); - } - inline void Swap(HelloResponse* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(HelloResponse& a, HelloResponse& b) { a.Swap(&b); } + inline void Swap(HelloResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HelloResponse* other) { + void UnsafeArenaSwap(HelloResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -156,55 +143,66 @@ class HelloResponse final : // implements Message ---------------------------------------------- - HelloResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HelloResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HelloResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "HelloResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HelloResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "HelloResponse"; } + + explicit HelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HelloResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloResponse& from); + HelloResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HelloResponse&& from) noexcept + : HelloResponse(arena) { + *this = ::std::move(from); } - protected: - explicit HelloResponse(::google::protobuf::Arena* arena); - HelloResponse(::google::protobuf::Arena* arena, const HelloResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kGreetingFieldNumber = 1, }; // string greeting = 1; void clear_greeting() ; - const std::string& greeting() const; - template + const ::std::string& greeting() const; + template void set_greeting(Arg_&& arg, Args_... args); - std::string* mutable_greeting(); - PROTOBUF_NODISCARD std::string* release_greeting(); - void set_allocated_greeting(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_greeting(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_greeting(); + void set_allocated_greeting(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_greeting() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_greeting( - const std::string& value); - std::string* _internal_mutable_greeting(); + const ::std::string& _internal_greeting() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_greeting(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_greeting(); public: // @@protoc_insertion_point(class_scope:HelloResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 30, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -213,47 +211,52 @@ class HelloResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HelloResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr greeting_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_HelloRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull HelloResponse_class_data_; +// ------------------------------------------------------------------- -class HelloRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:HelloRequest) */ { +class HelloRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:HelloRequest) */ { public: inline HelloRequest() : HelloRequest(nullptr) {} - ~HelloRequest() override; - template - explicit PROTOBUF_CONSTEXPR HelloRequest(::google::protobuf::internal::ConstantInitialized); + ~HelloRequest() PROTOBUF_FINAL; - inline HelloRequest(const HelloRequest& from) - : HelloRequest(nullptr, from) {} - HelloRequest(HelloRequest&& from) noexcept - : HelloRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HelloRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HelloRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HelloRequest(::google::protobuf::internal::ConstantInitialized); + inline HelloRequest(const HelloRequest& from) : HelloRequest(nullptr, from) {} + inline HelloRequest(HelloRequest&& from) noexcept + : HelloRequest(nullptr, ::std::move(from)) {} inline HelloRequest& operator=(const HelloRequest& from) { CopyFrom(from); return *this; } inline HelloRequest& operator=(HelloRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -265,47 +268,35 @@ class HelloRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HelloRequest& default_instance() { - return *internal_default_instance(); - } - static inline const HelloRequest* internal_default_instance() { - return reinterpret_cast( - &_HelloRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(HelloRequest& a, HelloRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_HelloRequest_default_instance_); } - inline void Swap(HelloRequest* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(HelloRequest& a, HelloRequest& b) { a.Swap(&b); } + inline void Swap(HelloRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HelloRequest* other) { + void UnsafeArenaSwap(HelloRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -313,55 +304,66 @@ class HelloRequest final : // implements Message ---------------------------------------------- - HelloRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HelloRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HelloRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "HelloRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HelloRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "HelloRequest"; } + + explicit HelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HelloRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HelloRequest& from); + HelloRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HelloRequest&& from) noexcept + : HelloRequest(arena) { + *this = ::std::move(from); } - protected: - explicit HelloRequest(::google::protobuf::Arena* arena); - HelloRequest(::google::protobuf::Arena* arena, const HelloRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kMyNameFieldNumber = 1, }; // string myName = 1; void clear_myname() ; - const std::string& myname() const; - template + const ::std::string& myname() const; + template void set_myname(Arg_&& arg, Args_... args); - std::string* mutable_myname(); - PROTOBUF_NODISCARD std::string* release_myname(); - void set_allocated_myname(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_myname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_myname(); + void set_allocated_myname(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_myname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_myname( - const std::string& value); - std::string* _internal_mutable_myname(); + const ::std::string& _internal_myname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_myname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_myname(); public: // @@protoc_insertion_point(class_scope:HelloRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 27, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -370,21 +372,25 @@ class HelloRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HelloRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr myname_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_HelloRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull HelloRequest_class_data_; + // =================================================================== @@ -403,54 +409,66 @@ class HelloRequest final : // string myName = 1; inline void HelloRequest::clear_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.myname_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HelloRequest::myname() const +inline const ::std::string& HelloRequest::myname() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:HelloRequest.myName) return _internal_myname(); } template -inline PROTOBUF_ALWAYS_INLINE void HelloRequest::set_myname(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HelloRequest::set_myname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.myname_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:HelloRequest.myName) } -inline std::string* HelloRequest::mutable_myname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_myname(); +inline ::std::string* PROTOBUF_NONNULL HelloRequest::mutable_myname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_myname(); // @@protoc_insertion_point(field_mutable:HelloRequest.myName) return _s; } -inline const std::string& HelloRequest::_internal_myname() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HelloRequest::_internal_myname() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.myname_.Get(); } -inline void HelloRequest::_internal_set_myname(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HelloRequest::_internal_set_myname(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.myname_.Set(value, GetArena()); } -inline std::string* HelloRequest::_internal_mutable_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HelloRequest::_internal_mutable_myname() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.myname_.Mutable( GetArena()); } -inline std::string* HelloRequest::release_myname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HelloRequest::release_myname() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:HelloRequest.myName) - return _impl_.myname_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.myname_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.myname_.Set("", GetArena()); + } + return released; } -inline void HelloRequest::set_allocated_myname(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HelloRequest::set_allocated_myname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.myname_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.myname_.IsDefault()) { - _impl_.myname_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.myname_.IsDefault()) { + _impl_.myname_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:HelloRequest.myName) } @@ -460,54 +478,66 @@ inline void HelloRequest::set_allocated_myname(std::string* value) { // string greeting = 1; inline void HelloResponse::clear_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.greeting_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HelloResponse::greeting() const +inline const ::std::string& HelloResponse::greeting() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:HelloResponse.greeting) return _internal_greeting(); } template -inline PROTOBUF_ALWAYS_INLINE void HelloResponse::set_greeting(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HelloResponse::set_greeting(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.greeting_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:HelloResponse.greeting) } -inline std::string* HelloResponse::mutable_greeting() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_greeting(); +inline ::std::string* PROTOBUF_NONNULL HelloResponse::mutable_greeting() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_greeting(); // @@protoc_insertion_point(field_mutable:HelloResponse.greeting) return _s; } -inline const std::string& HelloResponse::_internal_greeting() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HelloResponse::_internal_greeting() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.greeting_.Get(); } -inline void HelloResponse::_internal_set_greeting(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HelloResponse::_internal_set_greeting(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.greeting_.Set(value, GetArena()); } -inline std::string* HelloResponse::_internal_mutable_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HelloResponse::_internal_mutable_greeting() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.greeting_.Mutable( GetArena()); } -inline std::string* HelloResponse::release_greeting() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HelloResponse::release_greeting() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:HelloResponse.greeting) - return _impl_.greeting_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.greeting_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.greeting_.Set("", GetArena()); + } + return released; } -inline void HelloResponse::set_allocated_greeting(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HelloResponse::set_allocated_greeting(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.greeting_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.greeting_.IsDefault()) { - _impl_.greeting_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.greeting_.IsDefault()) { + _impl_.greeting_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:HelloResponse.greeting) } @@ -522,4 +552,4 @@ inline void HelloResponse::set_allocated_greeting(std::string* value) { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_HelloRpc_2eproto_2epb_2eh +#endif // HelloRpc_2eproto_2epb_2eh diff --git a/packages/streamr-proto-rpc/test/proto/TestProtos.pb.cc b/packages/streamr-proto-rpc/test/proto/TestProtos.pb.cc index bdc8b045..c62b712e 100644 --- a/packages/streamr-proto-rpc/test/proto/TestProtos.pb.cc +++ b/packages/streamr-proto-rpc/test/proto/TestProtos.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: TestProtos.proto +// Protobuf C++ Version: 6.33.4 #include "TestProtos.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" @@ -18,17 +23,24 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; inline constexpr PingResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : requestid_( + : _cached_size_{0}, + requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR PingResponse::PingResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PingResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PingResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR PingResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PingResponseDefaultTypeInternal() {} @@ -42,14 +54,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr PingRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : requestid_( + : _cached_size_{0}, + requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR PingRequest::PingRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PingRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PingRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PingRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PingRequestDefaultTypeInternal() {} @@ -70,7 +88,13 @@ inline constexpr OptionalResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR OptionalResponse::OptionalResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(OptionalResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct OptionalResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR OptionalResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OptionalResponseDefaultTypeInternal() {} @@ -91,7 +115,13 @@ inline constexpr OptionalRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR OptionalRequest::OptionalRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(OptionalRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct OptionalRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR OptionalRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OptionalRequestDefaultTypeInternal() {} @@ -105,15 +135,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ConnectivityMethod::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : ip_( + : _cached_size_{0}, + ip_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - port_{0u}, - _cached_size_{0} {} + port_{0u} {} template PROTOBUF_CONSTEXPR ConnectivityMethod::ConnectivityMethod(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityMethod_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityMethodDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityMethodDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityMethodDefaultTypeInternal() {} @@ -139,7 +175,13 @@ inline constexpr PeerDescriptor::Impl_::Impl_( template PROTOBUF_CONSTEXPR PeerDescriptor::PeerDescriptor(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PeerDescriptor_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PeerDescriptorDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerDescriptorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerDescriptorDefaultTypeInternal() {} @@ -166,7 +208,13 @@ inline constexpr RouteMessageWrapper::Impl_::Impl_( template PROTOBUF_CONSTEXPR RouteMessageWrapper::RouteMessageWrapper(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RouteMessageWrapper_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RouteMessageWrapperDefaultTypeInternal { PROTOBUF_CONSTEXPR RouteMessageWrapperDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RouteMessageWrapperDefaultTypeInternal() {} @@ -192,7 +240,13 @@ inline constexpr RouteMessageAck::Impl_::Impl_( template PROTOBUF_CONSTEXPR RouteMessageAck::RouteMessageAck(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RouteMessageAck_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RouteMessageAckDefaultTypeInternal { PROTOBUF_CONSTEXPR RouteMessageAckDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RouteMessageAckDefaultTypeInternal() {} @@ -206,15 +260,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestPeersResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : peers_{}, + : _cached_size_{0}, + peers_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestPeersResponse::ClosestPeersResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestPeersResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestPeersResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestPeersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestPeersResponseDefaultTypeInternal() {} @@ -236,7 +296,13 @@ inline constexpr ClosestPeersRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ClosestPeersRequest::ClosestPeersRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestPeersRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestPeersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestPeersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestPeersRequestDefaultTypeInternal() {} @@ -247,153 +313,109 @@ struct ClosestPeersRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClosestPeersRequestDefaultTypeInternal _ClosestPeersRequest_default_instance_; -static ::_pb::Metadata file_level_metadata_TestProtos_2eproto[10]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_TestProtos_2eproto[1]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_TestProtos_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_TestProtos_2eproto = nullptr; -const ::uint32_t TableStruct_TestProtos_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _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(::RouteMessageWrapper, _impl_.sourcepeer_), - PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.destinationpeer_), - PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.previouspeer_), - PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.message_), - 0, - ~0u, - 1, - 2, - ~0u, - PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _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(::RouteMessageAck, _impl_.sourcepeer_), - PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.destinationpeer_), - PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.error_), - 0, - ~0u, - 1, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::PingRequest, _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(::PingRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::PingResponse, _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(::PingResponse, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::ClosestPeersRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::ClosestPeersRequest, _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(::ClosestPeersRequest, _impl_.peerdescriptor_), - PROTOBUF_FIELD_OFFSET(::ClosestPeersRequest, _impl_.requestid_), - 0, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::ClosestPeersResponse, _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(::ClosestPeersResponse, _impl_.peers_), - PROTOBUF_FIELD_OFFSET(::ClosestPeersResponse, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _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(::PeerDescriptor, _impl_.nodeid_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.type_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.udp_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.tcp_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.websocket_), - PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.openinternet_), - ~0u, - ~0u, - 0, - 1, - 2, - 3, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::ConnectivityMethod, _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(::ConnectivityMethod, _impl_.port_), - PROTOBUF_FIELD_OFFSET(::ConnectivityMethod, _impl_.ip_), - PROTOBUF_FIELD_OFFSET(::OptionalRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::OptionalRequest, _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(::OptionalRequest, _impl_.someoptionalfield_), - 0, - PROTOBUF_FIELD_OFFSET(::OptionalResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::OptionalResponse, _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(::OptionalResponse, _impl_.someoptionalfield_), - 0, +const ::uint32_t + TableStruct_TestProtos_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_._has_bits_), + 8, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.sourcepeer_), + PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.destinationpeer_), + PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.previouspeer_), + PROTOBUF_FIELD_OFFSET(::RouteMessageWrapper, _impl_.message_), + 2, + 0, + 3, + 4, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.sourcepeer_), + PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.destinationpeer_), + PROTOBUF_FIELD_OFFSET(::RouteMessageAck, _impl_.error_), + 2, + 0, + 3, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::PingRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::PingRequest, _impl_.requestid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::PingResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::PingResponse, _impl_.requestid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ClosestPeersRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ClosestPeersRequest, _impl_.peerdescriptor_), + PROTOBUF_FIELD_OFFSET(::ClosestPeersRequest, _impl_.requestid_), + 1, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ClosestPeersResponse, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ClosestPeersResponse, _impl_.peers_), + PROTOBUF_FIELD_OFFSET(::ClosestPeersResponse, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_._has_bits_), + 9, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.nodeid_), + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.udp_), + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.tcp_), + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.websocket_), + PROTOBUF_FIELD_OFFSET(::PeerDescriptor, _impl_.openinternet_), + 0, + 4, + 1, + 2, + 3, + 5, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ConnectivityMethod, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ConnectivityMethod, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::ConnectivityMethod, _impl_.ip_), + 1, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::OptionalRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::OptionalRequest, _impl_.someoptionalfield_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::OptionalResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::OptionalResponse, _impl_.someoptionalfield_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 13, -1, sizeof(::RouteMessageWrapper)}, - {18, 30, -1, sizeof(::RouteMessageAck)}, - {34, -1, -1, sizeof(::PingRequest)}, - {43, -1, -1, sizeof(::PingResponse)}, - {52, 62, -1, sizeof(::ClosestPeersRequest)}, - {64, -1, -1, sizeof(::ClosestPeersResponse)}, - {74, 88, -1, sizeof(::PeerDescriptor)}, - {94, -1, -1, sizeof(::ConnectivityMethod)}, - {104, 113, -1, sizeof(::OptionalRequest)}, - {114, 123, -1, sizeof(::OptionalResponse)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::RouteMessageWrapper)}, + {13, sizeof(::RouteMessageAck)}, + {24, sizeof(::PingRequest)}, + {29, sizeof(::PingResponse)}, + {34, sizeof(::ClosestPeersRequest)}, + {41, sizeof(::ClosestPeersResponse)}, + {48, sizeof(::PeerDescriptor)}, + {63, sizeof(::ConnectivityMethod)}, + {70, sizeof(::OptionalRequest)}, + {75, sizeof(::OptionalResponse)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::_RouteMessageWrapper_default_instance_._instance, &::_RouteMessageAck_default_instance_._instance, &::_PingRequest_default_instance_._instance, @@ -405,7 +427,8 @@ static const ::_pb::Message* const file_default_instances[] = { &::_OptionalRequest_default_instance_._instance, &::_OptionalResponse_default_instance_._instance, }; -const char descriptor_table_protodef_TestProtos_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_TestProtos_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n\020TestProtos.proto\"\257\001\n\023RouteMessageWrapp" "er\022#\n\nsourcePeer\030\001 \001(\0132\017.PeerDescriptor\022" "\021\n\trequestId\030\002 \001(\t\022(\n\017destinationPeer\030\003 " @@ -440,7 +463,7 @@ const char descriptor_table_protodef_TestProtos_2eproto[] PROTOBUF_SECTION_VARIA "sponseB\002H\002b\006proto3" }; static ::absl::once_flag descriptor_table_TestProtos_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_TestProtos_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_TestProtos_2eproto = { false, false, 1258, @@ -453,112 +476,79 @@ const ::_pbi::DescriptorTable descriptor_table_TestProtos_2eproto = { schemas, file_default_instances, TableStruct_TestProtos_2eproto::offsets, - file_level_metadata_TestProtos_2eproto, file_level_enum_descriptors_TestProtos_2eproto, file_level_service_descriptors_TestProtos_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_TestProtos_2eproto_getter() { - return &descriptor_table_TestProtos_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_TestProtos_2eproto(&descriptor_table_TestProtos_2eproto); -const ::google::protobuf::EnumDescriptor* NodeType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL NodeType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_TestProtos_2eproto); return file_level_enum_descriptors_TestProtos_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t NodeType_internal_data_[] = { 131072u, 0u, }; -bool NodeType_IsValid(int value) { - return 0 <= value && value <= 1; -} // =================================================================== class RouteMessageWrapper::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._has_bits_); - static const ::PeerDescriptor& sourcepeer(const RouteMessageWrapper* msg); - static void set_has_sourcepeer(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::PeerDescriptor& destinationpeer(const RouteMessageWrapper* msg); - static void set_has_destinationpeer(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::PeerDescriptor& previouspeer(const RouteMessageWrapper* msg); - static void set_has_previouspeer(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._has_bits_); }; -const ::PeerDescriptor& RouteMessageWrapper::_Internal::sourcepeer(const RouteMessageWrapper* msg) { - return *msg->_impl_.sourcepeer_; -} -const ::PeerDescriptor& RouteMessageWrapper::_Internal::destinationpeer(const RouteMessageWrapper* msg) { - return *msg->_impl_.destinationpeer_; -} -const ::PeerDescriptor& RouteMessageWrapper::_Internal::previouspeer(const RouteMessageWrapper* msg) { - return *msg->_impl_.previouspeer_; -} -RouteMessageWrapper::RouteMessageWrapper(::google::protobuf::Arena* arena) +RouteMessageWrapper::RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageWrapper_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:RouteMessageWrapper) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::RouteMessageWrapper& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, requestid_(arena, from.requestid_), message_(arena, from.message_) {} RouteMessageWrapper::RouteMessageWrapper( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageWrapper& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageWrapper_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RouteMessageWrapper* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeer_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::PeerDescriptor>(arena, *from._impl_.sourcepeer_) + _impl_.sourcepeer_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeer_) : nullptr; - _impl_.destinationpeer_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::PeerDescriptor>(arena, *from._impl_.destinationpeer_) + _impl_.destinationpeer_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.destinationpeer_) : nullptr; - _impl_.previouspeer_ = (cached_has_bits & 0x00000004u) - ? CreateMaybeMessage<::PeerDescriptor>(arena, *from._impl_.previouspeer_) + _impl_.previouspeer_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.previouspeer_) : nullptr; // @@protoc_insertion_point(copy_constructor:RouteMessageWrapper) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, requestid_(arena), message_(arena) {} -inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* arena) { +inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeer_), 0, offsetof(Impl_, previouspeer_) - @@ -567,96 +557,202 @@ inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* arena) { } RouteMessageWrapper::~RouteMessageWrapper() { // @@protoc_insertion_point(destructor:RouteMessageWrapper) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RouteMessageWrapper::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.message_.Destroy(); - delete _impl_.sourcepeer_; - delete _impl_.destinationpeer_; - delete _impl_.previouspeer_; - _impl_.~Impl_(); +inline void RouteMessageWrapper::SharedDtor(MessageLite& self) { + RouteMessageWrapper& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.message_.Destroy(); + delete this_._impl_.sourcepeer_; + delete this_._impl_.destinationpeer_; + delete this_._impl_.previouspeer_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RouteMessageWrapper::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RouteMessageWrapper(arena); +} +constexpr auto RouteMessageWrapper::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RouteMessageWrapper), + alignof(RouteMessageWrapper)); +} +constexpr auto RouteMessageWrapper::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RouteMessageWrapper_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RouteMessageWrapper::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RouteMessageWrapper::SharedDtor, + static_cast(&RouteMessageWrapper::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._cached_size_), + false, + }, + &RouteMessageWrapper::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RouteMessageWrapper::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RouteMessageWrapper::InternalSwap(RouteMessageWrapper* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_ = + RouteMessageWrapper::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RouteMessageWrapper::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RouteMessageWrapper_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RouteMessageWrapper_class_data_.tc_table); + return RouteMessageWrapper_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 3, 37, 2> +RouteMessageWrapper::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RouteMessageWrapper_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::RouteMessageWrapper>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .PeerDescriptor sourcePeer = 1; + {::_pbi::TcParser::FastMtS1, + {10, 2, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.sourcepeer_)}}, + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.requestid_)}}, + // .PeerDescriptor destinationPeer = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 1, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.destinationpeer_)}}, + // .PeerDescriptor previousPeer = 4; + {::_pbi::TcParser::FastMtS1, + {34, 4, 2, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.previouspeer_)}}, + // bytes message = 5; + {::_pbi::TcParser::FastBS1, + {42, 1, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.message_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .PeerDescriptor sourcePeer = 1; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.sourcepeer_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .PeerDescriptor destinationPeer = 3; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.destinationpeer_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .PeerDescriptor previousPeer = 4; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.previouspeer_), _Internal::kHasBitsOffset + 4, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes message = 5; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + }}, + {{ + "\23\0\11\0\0\0\0\0" + "RouteMessageWrapper" + "requestId" + }}, +}; +void RouteMessageWrapper::InternalSwap(RouteMessageWrapper* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RouteMessageWrapper::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RouteMessageAck::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._has_bits_); - static const ::PeerDescriptor& sourcepeer(const RouteMessageAck* msg); - static void set_has_sourcepeer(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::PeerDescriptor& destinationpeer(const RouteMessageAck* msg); - static void set_has_destinationpeer(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._has_bits_); }; -const ::PeerDescriptor& RouteMessageAck::_Internal::sourcepeer(const RouteMessageAck* msg) { - return *msg->_impl_.sourcepeer_; -} -const ::PeerDescriptor& RouteMessageAck::_Internal::destinationpeer(const RouteMessageAck* msg) { - return *msg->_impl_.destinationpeer_; -} -RouteMessageAck::RouteMessageAck(::google::protobuf::Arena* arena) +RouteMessageAck::RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageAck_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:RouteMessageAck) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::RouteMessageAck& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, requestid_(arena, from.requestid_), error_(arena, from.error_) {} RouteMessageAck::RouteMessageAck( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageAck& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageAck_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RouteMessageAck* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeer_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::PeerDescriptor>(arena, *from._impl_.sourcepeer_) + _impl_.sourcepeer_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeer_) : nullptr; - _impl_.destinationpeer_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::PeerDescriptor>(arena, *from._impl_.destinationpeer_) + _impl_.destinationpeer_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.destinationpeer_) : nullptr; // @@protoc_insertion_point(copy_constructor:RouteMessageAck) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, requestid_(arena), error_(arena) {} -inline void RouteMessageAck::SharedCtor(::_pb::Arena* arena) { +inline void RouteMessageAck::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeer_), 0, offsetof(Impl_, destinationpeer_) - @@ -665,360 +761,836 @@ inline void RouteMessageAck::SharedCtor(::_pb::Arena* arena) { } RouteMessageAck::~RouteMessageAck() { // @@protoc_insertion_point(destructor:RouteMessageAck) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RouteMessageAck::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.error_.Destroy(); - delete _impl_.sourcepeer_; - delete _impl_.destinationpeer_; - _impl_.~Impl_(); +inline void RouteMessageAck::SharedDtor(MessageLite& self) { + RouteMessageAck& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.error_.Destroy(); + delete this_._impl_.sourcepeer_; + delete this_._impl_.destinationpeer_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RouteMessageAck::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RouteMessageAck(arena); +} +constexpr auto RouteMessageAck::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RouteMessageAck), + alignof(RouteMessageAck)); +} +constexpr auto RouteMessageAck::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RouteMessageAck_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RouteMessageAck::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RouteMessageAck::SharedDtor, + static_cast(&RouteMessageAck::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._cached_size_), + false, + }, + &RouteMessageAck::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RouteMessageAck::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RouteMessageAck::InternalSwap(RouteMessageAck* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_ = + RouteMessageAck::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RouteMessageAck::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RouteMessageAck_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RouteMessageAck_class_data_.tc_table); + return RouteMessageAck_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 2, 38, 2> +RouteMessageAck::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RouteMessageAck_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::RouteMessageAck>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string error = 4; + {::_pbi::TcParser::FastUS1, + {34, 1, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.error_)}}, + // .PeerDescriptor sourcePeer = 1; + {::_pbi::TcParser::FastMtS1, + {10, 2, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.sourcepeer_)}}, + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.requestid_)}}, + // .PeerDescriptor destinationPeer = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 1, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.destinationpeer_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .PeerDescriptor sourcePeer = 1; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.sourcepeer_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .PeerDescriptor destinationPeer = 3; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.destinationpeer_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string error = 4; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.error_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + }}, + {{ + "\17\0\11\0\5\0\0\0" + "RouteMessageAck" + "requestId" + "error" + }}, +}; +void RouteMessageAck::InternalSwap(RouteMessageAck* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RouteMessageAck::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PingRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PingRequest, _impl_._has_bits_); }; -PingRequest::PingRequest(::google::protobuf::Arena* arena) +PingRequest::PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:PingRequest) } -inline PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::PingRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + requestid_(arena, from.requestid_) {} PingRequest::PingRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PingRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:PingRequest) } -inline PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + requestid_(arena) {} -inline void PingRequest::SharedCtor(::_pb::Arena* arena) { +inline void PingRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PingRequest::~PingRequest() { // @@protoc_insertion_point(destructor:PingRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PingRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void PingRequest::SharedDtor(MessageLite& self) { + PingRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PingRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PingRequest(arena); +} +constexpr auto PingRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PingRequest), + alignof(PingRequest)); +} +constexpr auto PingRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PingRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PingRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PingRequest::SharedDtor, + static_cast(&PingRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PingRequest, _impl_._cached_size_), + false, + }, + &PingRequest::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PingRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PingRequest::InternalSwap(PingRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PingRequest_class_data_ = + PingRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PingRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PingRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PingRequest_class_data_.tc_table); + return PingRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 29, 2> +PingRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PingRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + PingRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::PingRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PingRequest, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(PingRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\13\11\0\0\0\0\0\0" + "PingRequest" + "requestId" + }}, +}; +void PingRequest::InternalSwap(PingRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PingRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PingResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PingResponse, _impl_._has_bits_); }; -PingResponse::PingResponse(::google::protobuf::Arena* arena) +PingResponse::PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:PingResponse) } -inline PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::PingResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + requestid_(arena, from.requestid_) {} PingResponse::PingResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PingResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:PingResponse) } -inline PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + requestid_(arena) {} -inline void PingResponse::SharedCtor(::_pb::Arena* arena) { +inline void PingResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PingResponse::~PingResponse() { // @@protoc_insertion_point(destructor:PingResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PingResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void PingResponse::SharedDtor(MessageLite& self) { + PingResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PingResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PingResponse(arena); +} +constexpr auto PingResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PingResponse), + alignof(PingResponse)); +} +constexpr auto PingResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PingResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PingResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PingResponse::SharedDtor, + static_cast(&PingResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PingResponse, _impl_._cached_size_), + false, + }, + &PingResponse::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PingResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PingResponse::InternalSwap(PingResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PingResponse_class_data_ = + PingResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PingResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PingResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PingResponse_class_data_.tc_table); + return PingResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 30, 2> +PingResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PingResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + PingResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::PingResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PingResponse, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(PingResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\14\11\0\0\0\0\0\0" + "PingResponse" + "requestId" + }}, +}; +void PingResponse::InternalSwap(PingResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PingResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[3]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestPeersRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._has_bits_); - static const ::PeerDescriptor& peerdescriptor(const ClosestPeersRequest* msg); - static void set_has_peerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._has_bits_); }; -const ::PeerDescriptor& ClosestPeersRequest::_Internal::peerdescriptor(const ClosestPeersRequest* msg) { - return *msg->_impl_.peerdescriptor_; -} -ClosestPeersRequest::ClosestPeersRequest(::google::protobuf::Arena* arena) +ClosestPeersRequest::ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ClosestPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::ClosestPeersRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, requestid_(arena, from.requestid_) {} ClosestPeersRequest::ClosestPeersRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestPeersRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.peerdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::PeerDescriptor>(arena, *from._impl_.peerdescriptor_) + _impl_.peerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.peerdescriptor_) : nullptr; // @@protoc_insertion_point(copy_constructor:ClosestPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, requestid_(arena) {} -inline void ClosestPeersRequest::SharedCtor(::_pb::Arena* arena) { +inline void ClosestPeersRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.peerdescriptor_ = {}; } ClosestPeersRequest::~ClosestPeersRequest() { // @@protoc_insertion_point(destructor:ClosestPeersRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestPeersRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - delete _impl_.peerdescriptor_; - _impl_.~Impl_(); +inline void ClosestPeersRequest::SharedDtor(MessageLite& self) { + ClosestPeersRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + delete this_._impl_.peerdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestPeersRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestPeersRequest(arena); +} +constexpr auto ClosestPeersRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClosestPeersRequest), + alignof(ClosestPeersRequest)); +} +constexpr auto ClosestPeersRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestPeersRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestPeersRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestPeersRequest::SharedDtor, + static_cast(&ClosestPeersRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._cached_size_), + false, + }, + &ClosestPeersRequest::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ClosestPeersRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ClosestPeersRequest::InternalSwap(ClosestPeersRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_ = + ClosestPeersRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestPeersRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestPeersRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestPeersRequest_class_data_.tc_table); + return ClosestPeersRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 37, 2> +ClosestPeersRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._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), + ClosestPeersRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ClosestPeersRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.requestid_)}}, + // .PeerDescriptor peerDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.peerdescriptor_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .PeerDescriptor peerDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.peerdescriptor_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + }}, + {{ + "\23\0\11\0\0\0\0\0" + "ClosestPeersRequest" + "requestId" + }}, +}; +void ClosestPeersRequest::InternalSwap(ClosestPeersRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestPeersRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[4]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestPeersResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._has_bits_); }; -ClosestPeersResponse::ClosestPeersResponse(::google::protobuf::Arena* arena) +ClosestPeersResponse::ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ClosestPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : peers_{visibility, arena, from.peers_}, - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::ClosestPeersResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + peers_{visibility, arena, from.peers_}, + requestid_(arena, from.requestid_) {} ClosestPeersResponse::ClosestPeersResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestPeersResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:ClosestPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : peers_{visibility, arena}, - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + peers_{visibility, arena}, + requestid_(arena) {} -inline void ClosestPeersResponse::SharedCtor(::_pb::Arena* arena) { +inline void ClosestPeersResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestPeersResponse::~ClosestPeersResponse() { // @@protoc_insertion_point(destructor:ClosestPeersResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestPeersResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestPeersResponse::SharedDtor(MessageLite& self) { + ClosestPeersResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestPeersResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestPeersResponse(arena); +} +constexpr auto ClosestPeersResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_) + + decltype(ClosestPeersResponse::_impl_.peers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(ClosestPeersResponse), alignof(ClosestPeersResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ClosestPeersResponse::PlacementNew_, + sizeof(ClosestPeersResponse), + alignof(ClosestPeersResponse)); + } } - -::_pbi::CachedSize* ClosestPeersResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ClosestPeersResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestPeersResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestPeersResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestPeersResponse::SharedDtor, + static_cast(&ClosestPeersResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._cached_size_), + false, + }, + &ClosestPeersResponse::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -void ClosestPeersResponse::InternalSwap(ClosestPeersResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_ = + ClosestPeersResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestPeersResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestPeersResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestPeersResponse_class_data_.tc_table); + return ClosestPeersResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 38, 2> +ClosestPeersResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._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), + ClosestPeersResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ClosestPeersResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.requestid_)}}, + // repeated .PeerDescriptor peers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .PeerDescriptor peers = 1; + {PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::PeerDescriptor>()}, + }}, + {{ + "\24\0\11\0\0\0\0\0" + "ClosestPeersResponse" + "requestId" + }}, +}; +void ClosestPeersResponse::InternalSwap(ClosestPeersResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestPeersResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[5]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerDescriptor::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._has_bits_); - static const ::ConnectivityMethod& udp(const PeerDescriptor* msg); - static void set_has_udp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::ConnectivityMethod& tcp(const PeerDescriptor* msg); - static void set_has_tcp(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::ConnectivityMethod& websocket(const PeerDescriptor* msg); - static void set_has_websocket(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_openinternet(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } + 8 * PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._has_bits_); }; -const ::ConnectivityMethod& PeerDescriptor::_Internal::udp(const PeerDescriptor* msg) { - return *msg->_impl_.udp_; -} -const ::ConnectivityMethod& PeerDescriptor::_Internal::tcp(const PeerDescriptor* msg) { - return *msg->_impl_.tcp_; -} -const ::ConnectivityMethod& PeerDescriptor::_Internal::websocket(const PeerDescriptor* msg) { - return *msg->_impl_.websocket_; -} -PeerDescriptor::PeerDescriptor(::google::protobuf::Arena* arena) +PeerDescriptor::PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PeerDescriptor_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:PeerDescriptor) } -inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::PeerDescriptor& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, nodeid_(arena, from.nodeid_) {} PeerDescriptor::PeerDescriptor( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PeerDescriptor& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PeerDescriptor_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PeerDescriptor* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.udp_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::ConnectivityMethod>(arena, *from._impl_.udp_) + _impl_.udp_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.udp_) : nullptr; - _impl_.tcp_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::ConnectivityMethod>(arena, *from._impl_.tcp_) + _impl_.tcp_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.tcp_) : nullptr; - _impl_.websocket_ = (cached_has_bits & 0x00000004u) - ? CreateMaybeMessage<::ConnectivityMethod>(arena, *from._impl_.websocket_) + _impl_.websocket_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.websocket_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, type_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, type_), offsetof(Impl_, openinternet_) - offsetof(Impl_, type_) + @@ -1026,15 +1598,15 @@ PeerDescriptor::PeerDescriptor( // @@protoc_insertion_point(copy_constructor:PeerDescriptor) } -inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, nodeid_(arena) {} -inline void PeerDescriptor::SharedCtor(::_pb::Arena* arena) { +inline void PeerDescriptor::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, udp_), 0, offsetof(Impl_, openinternet_) - @@ -1043,228 +1615,611 @@ inline void PeerDescriptor::SharedCtor(::_pb::Arena* arena) { } PeerDescriptor::~PeerDescriptor() { // @@protoc_insertion_point(destructor:PeerDescriptor) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PeerDescriptor::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.nodeid_.Destroy(); - delete _impl_.udp_; - delete _impl_.tcp_; - delete _impl_.websocket_; - _impl_.~Impl_(); +inline void PeerDescriptor::SharedDtor(MessageLite& self) { + PeerDescriptor& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.nodeid_.Destroy(); + delete this_._impl_.udp_; + delete this_._impl_.tcp_; + delete this_._impl_.websocket_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PeerDescriptor::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PeerDescriptor(arena); +} +constexpr auto PeerDescriptor::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PeerDescriptor), + alignof(PeerDescriptor)); +} +constexpr auto PeerDescriptor::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PeerDescriptor_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PeerDescriptor::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PeerDescriptor::SharedDtor, + static_cast(&PeerDescriptor::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._cached_size_), + false, + }, + &PeerDescriptor::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PeerDescriptor::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PeerDescriptor::InternalSwap(PeerDescriptor* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_ = + PeerDescriptor::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PeerDescriptor::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PeerDescriptor_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PeerDescriptor_class_data_.tc_table); + return PeerDescriptor_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 6, 3, 0, 2> +PeerDescriptor::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + PeerDescriptor_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::PeerDescriptor>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bytes nodeId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.nodeid_)}}, + // .NodeType type = 2; + {::_pbi::TcParser::FastV32S1, + {16, 4, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.type_)}}, + // .ConnectivityMethod udp = 3; + {::_pbi::TcParser::FastMtS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.udp_)}}, + // .ConnectivityMethod tcp = 4; + {::_pbi::TcParser::FastMtS1, + {34, 2, 1, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.tcp_)}}, + // .ConnectivityMethod websocket = 5; + {::_pbi::TcParser::FastMtS1, + {42, 3, 2, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.websocket_)}}, + // optional bool openInternet = 6; + {::_pbi::TcParser::FastV8S1, + {48, 5, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.openinternet_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes nodeId = 1; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.nodeid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .NodeType type = 2; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.type_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .ConnectivityMethod udp = 3; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.udp_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .ConnectivityMethod tcp = 4; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.tcp_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .ConnectivityMethod websocket = 5; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.websocket_), _Internal::kHasBitsOffset + 3, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional bool openInternet = 6; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.openinternet_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::ConnectivityMethod>()}, + {::_pbi::TcParser::GetTable<::ConnectivityMethod>()}, + {::_pbi::TcParser::GetTable<::ConnectivityMethod>()}, + }}, + {{ + }}, +}; +void PeerDescriptor::InternalSwap(PeerDescriptor* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PeerDescriptor::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[6]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityMethod::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._has_bits_); }; -ConnectivityMethod::ConnectivityMethod(::google::protobuf::Arena* arena) +ConnectivityMethod::ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityMethod_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ConnectivityMethod) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : ip_(arena, from.ip_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::ConnectivityMethod& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + ip_(arena, from.ip_) {} ConnectivityMethod::ConnectivityMethod( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityMethod& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityMethod_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityMethod* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.port_ = from._impl_.port_; // @@protoc_insertion_point(copy_constructor:ConnectivityMethod) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : ip_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + ip_(arena) {} -inline void ConnectivityMethod::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityMethod::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.port_ = {}; } ConnectivityMethod::~ConnectivityMethod() { // @@protoc_insertion_point(destructor:ConnectivityMethod) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityMethod::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.ip_.Destroy(); - _impl_.~Impl_(); +inline void ConnectivityMethod::SharedDtor(MessageLite& self) { + ConnectivityMethod& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.ip_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityMethod::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityMethod(arena); +} +constexpr auto ConnectivityMethod::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityMethod), + alignof(ConnectivityMethod)); +} +constexpr auto ConnectivityMethod::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityMethod_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityMethod::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityMethod::SharedDtor, + static_cast(&ConnectivityMethod::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._cached_size_), + false, + }, + &ConnectivityMethod::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityMethod::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityMethod::InternalSwap(ConnectivityMethod* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_ = + ConnectivityMethod::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityMethod::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityMethod_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityMethod_class_data_.tc_table); + return ConnectivityMethod_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 29, 2> +ConnectivityMethod::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._has_bits_), + 0, // no _extensions_ + 3, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967289, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ConnectivityMethod_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ConnectivityMethod>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 port = 2; + {::_pbi::TcParser::FastV32S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.port_)}}, + // string ip = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.ip_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.port_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string ip = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.ip_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\22\0\2\0\0\0\0\0" + "ConnectivityMethod" + "ip" + }}, +}; +void ConnectivityMethod::InternalSwap(ConnectivityMethod* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityMethod::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[7]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OptionalRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(OptionalRequest, _impl_._has_bits_); - static void set_has_someoptionalfield(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(OptionalRequest, _impl_._has_bits_); }; -OptionalRequest::OptionalRequest(::google::protobuf::Arena* arena) +OptionalRequest::OptionalRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, OptionalRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:OptionalRequest) } -inline PROTOBUF_NDEBUG_INLINE OptionalRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE OptionalRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::OptionalRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, someoptionalfield_(arena, from.someoptionalfield_) {} OptionalRequest::OptionalRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionalRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, OptionalRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE OptionalRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:OptionalRequest) } -inline PROTOBUF_NDEBUG_INLINE OptionalRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE OptionalRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, someoptionalfield_(arena) {} -inline void OptionalRequest::SharedCtor(::_pb::Arena* arena) { +inline void OptionalRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } OptionalRequest::~OptionalRequest() { // @@protoc_insertion_point(destructor:OptionalRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void OptionalRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.someoptionalfield_.Destroy(); - _impl_.~Impl_(); +inline void OptionalRequest::SharedDtor(MessageLite& self) { + OptionalRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.someoptionalfield_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL OptionalRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) OptionalRequest(arena); +} +constexpr auto OptionalRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(OptionalRequest), + alignof(OptionalRequest)); +} +constexpr auto OptionalRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_OptionalRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &OptionalRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &OptionalRequest::SharedDtor, + static_cast(&OptionalRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(OptionalRequest, _impl_._cached_size_), + false, + }, + &OptionalRequest::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* OptionalRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void OptionalRequest::InternalSwap(OptionalRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull OptionalRequest_class_data_ = + OptionalRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +OptionalRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&OptionalRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(OptionalRequest_class_data_.tc_table); + return OptionalRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 41, 2> +OptionalRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(OptionalRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + OptionalRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::OptionalRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // optional string someOptionalField = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(OptionalRequest, _impl_.someoptionalfield_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // optional string someOptionalField = 1; + {PROTOBUF_FIELD_OFFSET(OptionalRequest, _impl_.someoptionalfield_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\17\21\0\0\0\0\0\0" + "OptionalRequest" + "someOptionalField" + }}, +}; +void OptionalRequest::InternalSwap(OptionalRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata OptionalRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[8]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OptionalResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(OptionalResponse, _impl_._has_bits_); - static void set_has_someoptionalfield(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(OptionalResponse, _impl_._has_bits_); }; -OptionalResponse::OptionalResponse(::google::protobuf::Arena* arena) +OptionalResponse::OptionalResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, OptionalResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:OptionalResponse) } -inline PROTOBUF_NDEBUG_INLINE OptionalResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE OptionalResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::OptionalResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, someoptionalfield_(arena, from.someoptionalfield_) {} OptionalResponse::OptionalResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionalResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, OptionalResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE OptionalResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:OptionalResponse) } -inline PROTOBUF_NDEBUG_INLINE OptionalResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE OptionalResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, someoptionalfield_(arena) {} -inline void OptionalResponse::SharedCtor(::_pb::Arena* arena) { +inline void OptionalResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } OptionalResponse::~OptionalResponse() { // @@protoc_insertion_point(destructor:OptionalResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void OptionalResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.someoptionalfield_.Destroy(); - _impl_.~Impl_(); +inline void OptionalResponse::SharedDtor(MessageLite& self) { + OptionalResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.someoptionalfield_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL OptionalResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) OptionalResponse(arena); +} +constexpr auto OptionalResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(OptionalResponse), + alignof(OptionalResponse)); +} +constexpr auto OptionalResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_OptionalResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &OptionalResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &OptionalResponse::SharedDtor, + static_cast(&OptionalResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(OptionalResponse, _impl_._cached_size_), + false, + }, + &OptionalResponse::kDescriptorMethods, + &descriptor_table_TestProtos_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* OptionalResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void OptionalResponse::InternalSwap(OptionalResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull OptionalResponse_class_data_ = + OptionalResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +OptionalResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&OptionalResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(OptionalResponse_class_data_.tc_table); + return OptionalResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 42, 2> +OptionalResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(OptionalResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + OptionalResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::OptionalResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // optional string someOptionalField = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(OptionalResponse, _impl_.someoptionalfield_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // optional string someOptionalField = 1; + {PROTOBUF_FIELD_OFFSET(OptionalResponse, _impl_.someoptionalfield_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\20\21\0\0\0\0\0\0" + "OptionalResponse" + "someOptionalField" + }}, +}; +void OptionalResponse::InternalSwap(OptionalResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata OptionalResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_TestProtos_2eproto_getter, &descriptor_table_TestProtos_2eproto_once, - file_level_metadata_TestProtos_2eproto[9]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) namespace google { @@ -1272,4 +2227,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_TestProtos_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-proto-rpc/test/proto/TestProtos.pb.h b/packages/streamr-proto-rpc/test/proto/TestProtos.pb.h index d63b004d..00174554 100644 --- a/packages/streamr-proto-rpc/test/proto/TestProtos.pb.h +++ b/packages/streamr-proto-rpc/test/proto/TestProtos.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: TestProtos.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_TestProtos_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_TestProtos_2eproto_2epb_2eh +#ifndef TestProtos_2eproto_2epb_2eh +#define TestProtos_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,6 +24,7 @@ #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/generated_enum_reflection.h" @@ -44,7 +39,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -53,40 +49,56 @@ class AnyMetadata; struct TableStruct_TestProtos_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_TestProtos_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_TestProtos_2eproto; +} // extern "C" +enum NodeType : int; +extern const uint32_t NodeType_internal_data_[]; class ClosestPeersRequest; struct ClosestPeersRequestDefaultTypeInternal; extern ClosestPeersRequestDefaultTypeInternal _ClosestPeersRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_; class ClosestPeersResponse; struct ClosestPeersResponseDefaultTypeInternal; extern ClosestPeersResponseDefaultTypeInternal _ClosestPeersResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_; class ConnectivityMethod; struct ConnectivityMethodDefaultTypeInternal; extern ConnectivityMethodDefaultTypeInternal _ConnectivityMethod_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_; class OptionalRequest; struct OptionalRequestDefaultTypeInternal; extern OptionalRequestDefaultTypeInternal _OptionalRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull OptionalRequest_class_data_; class OptionalResponse; struct OptionalResponseDefaultTypeInternal; extern OptionalResponseDefaultTypeInternal _OptionalResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull OptionalResponse_class_data_; class PeerDescriptor; struct PeerDescriptorDefaultTypeInternal; extern PeerDescriptorDefaultTypeInternal _PeerDescriptor_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_; class PingRequest; struct PingRequestDefaultTypeInternal; extern PingRequestDefaultTypeInternal _PingRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PingRequest_class_data_; class PingResponse; struct PingResponseDefaultTypeInternal; extern PingResponseDefaultTypeInternal _PingResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PingResponse_class_data_; class RouteMessageAck; struct RouteMessageAckDefaultTypeInternal; extern RouteMessageAckDefaultTypeInternal _RouteMessageAck_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_; class RouteMessageWrapper; struct RouteMessageWrapperDefaultTypeInternal; extern RouteMessageWrapperDefaultTypeInternal _RouteMessageWrapper_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_; namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::NodeType_internal_data_> + internal::EnumTraitsImpl::value<::NodeType>; } // namespace protobuf } // namespace google @@ -94,34 +106,37 @@ enum NodeType : int { NODEJS = 0, BROWSER = 1, NodeType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), NodeType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool NodeType_IsValid(int value); extern const uint32_t NodeType_internal_data_[]; -constexpr NodeType NodeType_MIN = static_cast(0); -constexpr NodeType NodeType_MAX = static_cast(1); -constexpr int NodeType_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -NodeType_descriptor(); +inline constexpr NodeType NodeType_MIN = + static_cast(0); +inline constexpr NodeType NodeType_MAX = + static_cast(1); +inline bool NodeType_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int NodeType_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL NodeType_descriptor(); template -const std::string& NodeType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& NodeType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to NodeType_Name()."); return NodeType_Name(static_cast(value)); } template <> -inline const std::string& NodeType_Name(NodeType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& NodeType_Name(NodeType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool NodeType_Parse(absl::string_view name, NodeType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - NodeType_descriptor(), name, value); +inline bool NodeType_Parse( + ::absl::string_view name, NodeType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(NodeType_descriptor(), name, + value); } // =================================================================== @@ -129,32 +144,32 @@ inline bool NodeType_Parse(absl::string_view name, NodeType* value) { // ------------------------------------------------------------------- -class PingResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PingResponse) */ { +class PingResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:PingResponse) */ { public: inline PingResponse() : PingResponse(nullptr) {} - ~PingResponse() override; - template - explicit PROTOBUF_CONSTEXPR PingResponse(::google::protobuf::internal::ConstantInitialized); + ~PingResponse() PROTOBUF_FINAL; - inline PingResponse(const PingResponse& from) - : PingResponse(nullptr, from) {} - PingResponse(PingResponse&& from) noexcept - : PingResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PingResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PingResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR PingResponse(::google::protobuf::internal::ConstantInitialized); + inline PingResponse(const PingResponse& from) : PingResponse(nullptr, from) {} + inline PingResponse(PingResponse&& from) noexcept + : PingResponse(nullptr, ::std::move(from)) {} inline PingResponse& operator=(const PingResponse& from) { CopyFrom(from); return *this; } inline PingResponse& operator=(PingResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -166,47 +181,35 @@ class PingResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PingResponse& default_instance() { - return *internal_default_instance(); - } - static inline const PingResponse* internal_default_instance() { - return reinterpret_cast( - &_PingResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(PingResponse& a, PingResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_PingResponse_default_instance_); } - inline void Swap(PingResponse* other) { + static constexpr int kIndexInFileMessages = 3; + friend void swap(PingResponse& a, PingResponse& b) { a.Swap(&b); } + inline void Swap(PingResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PingResponse* other) { + void UnsafeArenaSwap(PingResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -214,55 +217,66 @@ class PingResponse final : // implements Message ---------------------------------------------- - PingResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PingResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PingResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "PingResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PingResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "PingResponse"; } + + explicit PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingResponse& from); + PingResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PingResponse&& from) noexcept + : PingResponse(arena) { + *this = ::std::move(from); } - protected: - explicit PingResponse(::google::protobuf::Arena* arena); - PingResponse(::google::protobuf::Arena* arena, const PingResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:PingResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 30, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -271,47 +285,52 @@ class PingResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PingResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; -class PingRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PingRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull PingResponse_class_data_; +// ------------------------------------------------------------------- + +class PingRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:PingRequest) */ { public: inline PingRequest() : PingRequest(nullptr) {} - ~PingRequest() override; - template - explicit PROTOBUF_CONSTEXPR PingRequest(::google::protobuf::internal::ConstantInitialized); + ~PingRequest() PROTOBUF_FINAL; - inline PingRequest(const PingRequest& from) - : PingRequest(nullptr, from) {} - PingRequest(PingRequest&& from) noexcept - : PingRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PingRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PingRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR PingRequest(::google::protobuf::internal::ConstantInitialized); + inline PingRequest(const PingRequest& from) : PingRequest(nullptr, from) {} + inline PingRequest(PingRequest&& from) noexcept + : PingRequest(nullptr, ::std::move(from)) {} inline PingRequest& operator=(const PingRequest& from) { CopyFrom(from); return *this; } inline PingRequest& operator=(PingRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -323,47 +342,35 @@ class PingRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PingRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_PingRequest_default_instance_); } - static inline const PingRequest* internal_default_instance() { - return reinterpret_cast( - &_PingRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(PingRequest& a, PingRequest& b) { - a.Swap(&b); - } - inline void Swap(PingRequest* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(PingRequest& a, PingRequest& b) { a.Swap(&b); } + inline void Swap(PingRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PingRequest* other) { + void UnsafeArenaSwap(PingRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -371,55 +378,66 @@ class PingRequest final : // implements Message ---------------------------------------------- - PingRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PingRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PingRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "PingRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PingRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "PingRequest"; } + + explicit PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingRequest& from); + PingRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PingRequest&& from) noexcept + : PingRequest(arena) { + *this = ::std::move(from); } - protected: - explicit PingRequest(::google::protobuf::Arena* arena); - PingRequest(::google::protobuf::Arena* arena, const PingRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:PingRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 29, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -428,47 +446,52 @@ class PingRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PingRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull PingRequest_class_data_; +// ------------------------------------------------------------------- -class OptionalResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:OptionalResponse) */ { +class OptionalResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:OptionalResponse) */ { public: inline OptionalResponse() : OptionalResponse(nullptr) {} - ~OptionalResponse() override; - template - explicit PROTOBUF_CONSTEXPR OptionalResponse(::google::protobuf::internal::ConstantInitialized); + ~OptionalResponse() PROTOBUF_FINAL; - inline OptionalResponse(const OptionalResponse& from) - : OptionalResponse(nullptr, from) {} - OptionalResponse(OptionalResponse&& from) noexcept - : OptionalResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(OptionalResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(OptionalResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR OptionalResponse(::google::protobuf::internal::ConstantInitialized); + inline OptionalResponse(const OptionalResponse& from) : OptionalResponse(nullptr, from) {} + inline OptionalResponse(OptionalResponse&& from) noexcept + : OptionalResponse(nullptr, ::std::move(from)) {} inline OptionalResponse& operator=(const OptionalResponse& from) { CopyFrom(from); return *this; } inline OptionalResponse& operator=(OptionalResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -480,47 +503,35 @@ class OptionalResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const OptionalResponse& default_instance() { - return *internal_default_instance(); - } - static inline const OptionalResponse* internal_default_instance() { - return reinterpret_cast( - &_OptionalResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(OptionalResponse& a, OptionalResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_OptionalResponse_default_instance_); } - inline void Swap(OptionalResponse* other) { + static constexpr int kIndexInFileMessages = 9; + friend void swap(OptionalResponse& a, OptionalResponse& b) { a.Swap(&b); } + inline void Swap(OptionalResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(OptionalResponse* other) { + void UnsafeArenaSwap(OptionalResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -528,56 +539,67 @@ class OptionalResponse final : // implements Message ---------------------------------------------- - OptionalResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + OptionalResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(OptionalResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "OptionalResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(OptionalResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "OptionalResponse"; } + + explicit OptionalResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + OptionalResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionalResponse& from); + OptionalResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OptionalResponse&& from) noexcept + : OptionalResponse(arena) { + *this = ::std::move(from); } - protected: - explicit OptionalResponse(::google::protobuf::Arena* arena); - OptionalResponse(::google::protobuf::Arena* arena, const OptionalResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kSomeOptionalFieldFieldNumber = 1, }; // optional string someOptionalField = 1; bool has_someoptionalfield() const; void clear_someoptionalfield() ; - const std::string& someoptionalfield() const; - template + const ::std::string& someoptionalfield() const; + template void set_someoptionalfield(Arg_&& arg, Args_... args); - std::string* mutable_someoptionalfield(); - PROTOBUF_NODISCARD std::string* release_someoptionalfield(); - void set_allocated_someoptionalfield(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_someoptionalfield(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_someoptionalfield(); + void set_allocated_someoptionalfield(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_someoptionalfield() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_someoptionalfield( - const std::string& value); - std::string* _internal_mutable_someoptionalfield(); + const ::std::string& _internal_someoptionalfield() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_someoptionalfield(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_someoptionalfield(); public: // @@protoc_insertion_point(class_scope:OptionalResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 42, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -586,48 +608,52 @@ class OptionalResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const OptionalResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr someoptionalfield_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; -class OptionalRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:OptionalRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull OptionalResponse_class_data_; +// ------------------------------------------------------------------- + +class OptionalRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:OptionalRequest) */ { public: inline OptionalRequest() : OptionalRequest(nullptr) {} - ~OptionalRequest() override; - template - explicit PROTOBUF_CONSTEXPR OptionalRequest(::google::protobuf::internal::ConstantInitialized); + ~OptionalRequest() PROTOBUF_FINAL; - inline OptionalRequest(const OptionalRequest& from) - : OptionalRequest(nullptr, from) {} - OptionalRequest(OptionalRequest&& from) noexcept - : OptionalRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(OptionalRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(OptionalRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR OptionalRequest(::google::protobuf::internal::ConstantInitialized); + inline OptionalRequest(const OptionalRequest& from) : OptionalRequest(nullptr, from) {} + inline OptionalRequest(OptionalRequest&& from) noexcept + : OptionalRequest(nullptr, ::std::move(from)) {} inline OptionalRequest& operator=(const OptionalRequest& from) { CopyFrom(from); return *this; } inline OptionalRequest& operator=(OptionalRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -639,47 +665,35 @@ class OptionalRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const OptionalRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_OptionalRequest_default_instance_); } - static inline const OptionalRequest* internal_default_instance() { - return reinterpret_cast( - &_OptionalRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(OptionalRequest& a, OptionalRequest& b) { - a.Swap(&b); - } - inline void Swap(OptionalRequest* other) { + static constexpr int kIndexInFileMessages = 8; + friend void swap(OptionalRequest& a, OptionalRequest& b) { a.Swap(&b); } + inline void Swap(OptionalRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(OptionalRequest* other) { + void UnsafeArenaSwap(OptionalRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -687,56 +701,67 @@ class OptionalRequest final : // implements Message ---------------------------------------------- - OptionalRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + OptionalRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(OptionalRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "OptionalRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(OptionalRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "OptionalRequest"; } + + explicit OptionalRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + OptionalRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const OptionalRequest& from); + OptionalRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, OptionalRequest&& from) noexcept + : OptionalRequest(arena) { + *this = ::std::move(from); } - protected: - explicit OptionalRequest(::google::protobuf::Arena* arena); - OptionalRequest(::google::protobuf::Arena* arena, const OptionalRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kSomeOptionalFieldFieldNumber = 1, }; // optional string someOptionalField = 1; bool has_someoptionalfield() const; void clear_someoptionalfield() ; - const std::string& someoptionalfield() const; - template + const ::std::string& someoptionalfield() const; + template void set_someoptionalfield(Arg_&& arg, Args_... args); - std::string* mutable_someoptionalfield(); - PROTOBUF_NODISCARD std::string* release_someoptionalfield(); - void set_allocated_someoptionalfield(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_someoptionalfield(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_someoptionalfield(); + void set_allocated_someoptionalfield(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_someoptionalfield() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_someoptionalfield( - const std::string& value); - std::string* _internal_mutable_someoptionalfield(); + const ::std::string& _internal_someoptionalfield() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_someoptionalfield(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_someoptionalfield(); public: // @@protoc_insertion_point(class_scope:OptionalRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 41, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -745,48 +770,52 @@ class OptionalRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const OptionalRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr someoptionalfield_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull OptionalRequest_class_data_; +// ------------------------------------------------------------------- -class ConnectivityMethod final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ConnectivityMethod) */ { +class ConnectivityMethod final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ConnectivityMethod) */ { public: inline ConnectivityMethod() : ConnectivityMethod(nullptr) {} - ~ConnectivityMethod() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityMethod(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityMethod() PROTOBUF_FINAL; - inline ConnectivityMethod(const ConnectivityMethod& from) - : ConnectivityMethod(nullptr, from) {} - ConnectivityMethod(ConnectivityMethod&& from) noexcept - : ConnectivityMethod() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityMethod* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityMethod)); } +#endif + template + explicit PROTOBUF_CONSTEXPR ConnectivityMethod(::google::protobuf::internal::ConstantInitialized); + + inline ConnectivityMethod(const ConnectivityMethod& from) : ConnectivityMethod(nullptr, from) {} + inline ConnectivityMethod(ConnectivityMethod&& from) noexcept + : ConnectivityMethod(nullptr, ::std::move(from)) {} inline ConnectivityMethod& operator=(const ConnectivityMethod& from) { CopyFrom(from); return *this; } inline ConnectivityMethod& operator=(ConnectivityMethod&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -798,47 +827,35 @@ class ConnectivityMethod final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityMethod& default_instance() { - return *internal_default_instance(); - } - static inline const ConnectivityMethod* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityMethod_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(ConnectivityMethod& a, ConnectivityMethod& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ConnectivityMethod_default_instance_); } - inline void Swap(ConnectivityMethod* other) { + static constexpr int kIndexInFileMessages = 7; + friend void swap(ConnectivityMethod& a, ConnectivityMethod& b) { a.Swap(&b); } + inline void Swap(ConnectivityMethod* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityMethod* other) { + void UnsafeArenaSwap(ConnectivityMethod* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -846,51 +863,57 @@ class ConnectivityMethod final : // implements Message ---------------------------------------------- - ConnectivityMethod* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityMethod* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityMethod* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ConnectivityMethod"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityMethod* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ConnectivityMethod"; } + + explicit ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityMethod& from); + ConnectivityMethod( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityMethod&& from) noexcept + : ConnectivityMethod(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityMethod(::google::protobuf::Arena* arena); - ConnectivityMethod(::google::protobuf::Arena* arena, const ConnectivityMethod& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kIpFieldNumber = 3, kPortFieldNumber = 2, }; // string ip = 3; void clear_ip() ; - const std::string& ip() const; - template + const ::std::string& ip() const; + template void set_ip(Arg_&& arg, Args_... args); - std::string* mutable_ip(); - PROTOBUF_NODISCARD std::string* release_ip(); - void set_allocated_ip(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_ip(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ip(); + void set_allocated_ip(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_ip() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip( - const std::string& value); - std::string* _internal_mutable_ip(); + const ::std::string& _internal_ip() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_ip(); public: // uint32 port = 2; @@ -906,6 +929,11 @@ class ConnectivityMethod final : // @@protoc_insertion_point(class_scope:ConnectivityMethod) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 29, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -914,48 +942,53 @@ class ConnectivityMethod final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityMethod& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr ip_; ::uint32_t port_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; -class PeerDescriptor final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:PeerDescriptor) */ { +extern const ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_; +// ------------------------------------------------------------------- + +class PeerDescriptor final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:PeerDescriptor) */ { public: inline PeerDescriptor() : PeerDescriptor(nullptr) {} - ~PeerDescriptor() override; - template - explicit PROTOBUF_CONSTEXPR PeerDescriptor(::google::protobuf::internal::ConstantInitialized); + ~PeerDescriptor() PROTOBUF_FINAL; - inline PeerDescriptor(const PeerDescriptor& from) - : PeerDescriptor(nullptr, from) {} - PeerDescriptor(PeerDescriptor&& from) noexcept - : PeerDescriptor() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PeerDescriptor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PeerDescriptor)); } +#endif + template + explicit PROTOBUF_CONSTEXPR PeerDescriptor(::google::protobuf::internal::ConstantInitialized); + + inline PeerDescriptor(const PeerDescriptor& from) : PeerDescriptor(nullptr, from) {} + inline PeerDescriptor(PeerDescriptor&& from) noexcept + : PeerDescriptor(nullptr, ::std::move(from)) {} inline PeerDescriptor& operator=(const PeerDescriptor& from) { CopyFrom(from); return *this; } inline PeerDescriptor& operator=(PeerDescriptor&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -967,47 +1000,35 @@ class PeerDescriptor final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerDescriptor& default_instance() { - return *internal_default_instance(); - } - static inline const PeerDescriptor* internal_default_instance() { - return reinterpret_cast( - &_PeerDescriptor_default_instance_); + return *reinterpret_cast( + &_PeerDescriptor_default_instance_); } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(PeerDescriptor& a, PeerDescriptor& b) { - a.Swap(&b); - } - inline void Swap(PeerDescriptor* other) { + static constexpr int kIndexInFileMessages = 6; + friend void swap(PeerDescriptor& a, PeerDescriptor& b) { a.Swap(&b); } + inline void Swap(PeerDescriptor* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PeerDescriptor* other) { + void UnsafeArenaSwap(PeerDescriptor* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1015,33 +1036,40 @@ class PeerDescriptor final : // implements Message ---------------------------------------------- - PeerDescriptor* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PeerDescriptor* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PeerDescriptor* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "PeerDescriptor"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PeerDescriptor* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "PeerDescriptor"; } + + explicit PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PeerDescriptor& from); + PeerDescriptor( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PeerDescriptor&& from) noexcept + : PeerDescriptor(arena) { + *this = ::std::move(from); } - protected: - explicit PeerDescriptor(::google::protobuf::Arena* arena); - PeerDescriptor(::google::protobuf::Arena* arena, const PeerDescriptor& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNodeIdFieldNumber = 1, kUdpFieldNumber = 3, @@ -1052,63 +1080,62 @@ class PeerDescriptor final : }; // bytes nodeId = 1; void clear_nodeid() ; - const std::string& nodeid() const; - template + const ::std::string& nodeid() const; + template void set_nodeid(Arg_&& arg, Args_... args); - std::string* mutable_nodeid(); - PROTOBUF_NODISCARD std::string* release_nodeid(); - void set_allocated_nodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nodeid(); + void set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid( - const std::string& value); - std::string* _internal_mutable_nodeid(); + const ::std::string& _internal_nodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nodeid(); public: // .ConnectivityMethod udp = 3; bool has_udp() const; void clear_udp() ; const ::ConnectivityMethod& udp() const; - PROTOBUF_NODISCARD ::ConnectivityMethod* release_udp(); - ::ConnectivityMethod* mutable_udp(); - void set_allocated_udp(::ConnectivityMethod* value); - void unsafe_arena_set_allocated_udp(::ConnectivityMethod* value); - ::ConnectivityMethod* unsafe_arena_release_udp(); + [[nodiscard]] ::ConnectivityMethod* PROTOBUF_NULLABLE release_udp(); + ::ConnectivityMethod* PROTOBUF_NONNULL mutable_udp(); + void set_allocated_udp(::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_udp(::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_udp(); private: const ::ConnectivityMethod& _internal_udp() const; - ::ConnectivityMethod* _internal_mutable_udp(); + ::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_udp(); public: // .ConnectivityMethod tcp = 4; bool has_tcp() const; void clear_tcp() ; const ::ConnectivityMethod& tcp() const; - PROTOBUF_NODISCARD ::ConnectivityMethod* release_tcp(); - ::ConnectivityMethod* mutable_tcp(); - void set_allocated_tcp(::ConnectivityMethod* value); - void unsafe_arena_set_allocated_tcp(::ConnectivityMethod* value); - ::ConnectivityMethod* unsafe_arena_release_tcp(); + [[nodiscard]] ::ConnectivityMethod* PROTOBUF_NULLABLE release_tcp(); + ::ConnectivityMethod* PROTOBUF_NONNULL mutable_tcp(); + void set_allocated_tcp(::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_tcp(::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_tcp(); private: const ::ConnectivityMethod& _internal_tcp() const; - ::ConnectivityMethod* _internal_mutable_tcp(); + ::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_tcp(); public: // .ConnectivityMethod websocket = 5; bool has_websocket() const; void clear_websocket() ; const ::ConnectivityMethod& websocket() const; - PROTOBUF_NODISCARD ::ConnectivityMethod* release_websocket(); - ::ConnectivityMethod* mutable_websocket(); - void set_allocated_websocket(::ConnectivityMethod* value); - void unsafe_arena_set_allocated_websocket(::ConnectivityMethod* value); - ::ConnectivityMethod* unsafe_arena_release_websocket(); + [[nodiscard]] ::ConnectivityMethod* PROTOBUF_NULLABLE release_websocket(); + ::ConnectivityMethod* PROTOBUF_NONNULL mutable_websocket(); + void set_allocated_websocket(::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_websocket(::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_websocket(); private: const ::ConnectivityMethod& _internal_websocket() const; - ::ConnectivityMethod* _internal_mutable_websocket(); + ::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_websocket(); public: // .NodeType type = 2; @@ -1135,6 +1162,11 @@ class PeerDescriptor final : // @@protoc_insertion_point(class_scope:PeerDescriptor) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 6, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1143,53 +1175,57 @@ class PeerDescriptor final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PeerDescriptor& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr nodeid_; - ::ConnectivityMethod* udp_; - ::ConnectivityMethod* tcp_; - ::ConnectivityMethod* websocket_; + ::ConnectivityMethod* PROTOBUF_NULLABLE udp_; + ::ConnectivityMethod* PROTOBUF_NULLABLE tcp_; + ::ConnectivityMethod* PROTOBUF_NULLABLE websocket_; int type_; bool openinternet_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_; +// ------------------------------------------------------------------- -class RouteMessageWrapper final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:RouteMessageWrapper) */ { +class RouteMessageWrapper final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:RouteMessageWrapper) */ { public: inline RouteMessageWrapper() : RouteMessageWrapper(nullptr) {} - ~RouteMessageWrapper() override; - template - explicit PROTOBUF_CONSTEXPR RouteMessageWrapper(::google::protobuf::internal::ConstantInitialized); + ~RouteMessageWrapper() PROTOBUF_FINAL; - inline RouteMessageWrapper(const RouteMessageWrapper& from) - : RouteMessageWrapper(nullptr, from) {} - RouteMessageWrapper(RouteMessageWrapper&& from) noexcept - : RouteMessageWrapper() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RouteMessageWrapper* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RouteMessageWrapper)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RouteMessageWrapper(::google::protobuf::internal::ConstantInitialized); + + inline RouteMessageWrapper(const RouteMessageWrapper& from) : RouteMessageWrapper(nullptr, from) {} + inline RouteMessageWrapper(RouteMessageWrapper&& from) noexcept + : RouteMessageWrapper(nullptr, ::std::move(from)) {} inline RouteMessageWrapper& operator=(const RouteMessageWrapper& from) { CopyFrom(from); return *this; } inline RouteMessageWrapper& operator=(RouteMessageWrapper&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1201,47 +1237,35 @@ class RouteMessageWrapper final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RouteMessageWrapper& default_instance() { - return *internal_default_instance(); - } - static inline const RouteMessageWrapper* internal_default_instance() { - return reinterpret_cast( - &_RouteMessageWrapper_default_instance_); + return *reinterpret_cast( + &_RouteMessageWrapper_default_instance_); } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(RouteMessageWrapper& a, RouteMessageWrapper& b) { - a.Swap(&b); - } - inline void Swap(RouteMessageWrapper* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(RouteMessageWrapper& a, RouteMessageWrapper& b) { a.Swap(&b); } + inline void Swap(RouteMessageWrapper* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RouteMessageWrapper* other) { + void UnsafeArenaSwap(RouteMessageWrapper* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1249,33 +1273,40 @@ class RouteMessageWrapper final : // implements Message ---------------------------------------------- - RouteMessageWrapper* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RouteMessageWrapper* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RouteMessageWrapper* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "RouteMessageWrapper"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RouteMessageWrapper* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "RouteMessageWrapper"; } + + explicit RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageWrapper& from); + RouteMessageWrapper( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RouteMessageWrapper&& from) noexcept + : RouteMessageWrapper(arena) { + *this = ::std::move(from); } - protected: - explicit RouteMessageWrapper(::google::protobuf::Arena* arena); - RouteMessageWrapper(::google::protobuf::Arena* arena, const RouteMessageWrapper& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 2, kMessageFieldNumber = 5, @@ -1285,84 +1316,87 @@ class RouteMessageWrapper final : }; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // bytes message = 5; void clear_message() ; - const std::string& message() const; - template + const ::std::string& message() const; + template void set_message(Arg_&& arg, Args_... args); - std::string* mutable_message(); - PROTOBUF_NODISCARD std::string* release_message(); - void set_allocated_message(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_message(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_message(); + void set_allocated_message(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_message() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_message( - const std::string& value); - std::string* _internal_mutable_message(); + const ::std::string& _internal_message() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_message(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_message(); public: // .PeerDescriptor sourcePeer = 1; bool has_sourcepeer() const; void clear_sourcepeer() ; const ::PeerDescriptor& sourcepeer() const; - PROTOBUF_NODISCARD ::PeerDescriptor* release_sourcepeer(); - ::PeerDescriptor* mutable_sourcepeer(); - void set_allocated_sourcepeer(::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeer(::PeerDescriptor* value); - ::PeerDescriptor* unsafe_arena_release_sourcepeer(); + [[nodiscard]] ::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeer(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeer(); + void set_allocated_sourcepeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + ::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeer(); private: const ::PeerDescriptor& _internal_sourcepeer() const; - ::PeerDescriptor* _internal_mutable_sourcepeer(); + ::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeer(); public: // .PeerDescriptor destinationPeer = 3; bool has_destinationpeer() const; void clear_destinationpeer() ; const ::PeerDescriptor& destinationpeer() const; - PROTOBUF_NODISCARD ::PeerDescriptor* release_destinationpeer(); - ::PeerDescriptor* mutable_destinationpeer(); - void set_allocated_destinationpeer(::PeerDescriptor* value); - void unsafe_arena_set_allocated_destinationpeer(::PeerDescriptor* value); - ::PeerDescriptor* unsafe_arena_release_destinationpeer(); + [[nodiscard]] ::PeerDescriptor* PROTOBUF_NULLABLE release_destinationpeer(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_destinationpeer(); + void set_allocated_destinationpeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_destinationpeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + ::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_destinationpeer(); private: const ::PeerDescriptor& _internal_destinationpeer() const; - ::PeerDescriptor* _internal_mutable_destinationpeer(); + ::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_destinationpeer(); public: // .PeerDescriptor previousPeer = 4; bool has_previouspeer() const; void clear_previouspeer() ; const ::PeerDescriptor& previouspeer() const; - PROTOBUF_NODISCARD ::PeerDescriptor* release_previouspeer(); - ::PeerDescriptor* mutable_previouspeer(); - void set_allocated_previouspeer(::PeerDescriptor* value); - void unsafe_arena_set_allocated_previouspeer(::PeerDescriptor* value); - ::PeerDescriptor* unsafe_arena_release_previouspeer(); + [[nodiscard]] ::PeerDescriptor* PROTOBUF_NULLABLE release_previouspeer(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_previouspeer(); + void set_allocated_previouspeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_previouspeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + ::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_previouspeer(); private: const ::PeerDescriptor& _internal_previouspeer() const; - ::PeerDescriptor* _internal_mutable_previouspeer(); + ::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_previouspeer(); public: // @@protoc_insertion_point(class_scope:RouteMessageWrapper) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 3, 37, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1371,52 +1405,56 @@ class RouteMessageWrapper final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RouteMessageWrapper& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr message_; - ::PeerDescriptor* sourcepeer_; - ::PeerDescriptor* destinationpeer_; - ::PeerDescriptor* previouspeer_; + ::PeerDescriptor* PROTOBUF_NULLABLE sourcepeer_; + ::PeerDescriptor* PROTOBUF_NULLABLE destinationpeer_; + ::PeerDescriptor* PROTOBUF_NULLABLE previouspeer_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_; +// ------------------------------------------------------------------- -class RouteMessageAck final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:RouteMessageAck) */ { +class RouteMessageAck final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:RouteMessageAck) */ { public: inline RouteMessageAck() : RouteMessageAck(nullptr) {} - ~RouteMessageAck() override; - template - explicit PROTOBUF_CONSTEXPR RouteMessageAck(::google::protobuf::internal::ConstantInitialized); + ~RouteMessageAck() PROTOBUF_FINAL; - inline RouteMessageAck(const RouteMessageAck& from) - : RouteMessageAck(nullptr, from) {} - RouteMessageAck(RouteMessageAck&& from) noexcept - : RouteMessageAck() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RouteMessageAck* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RouteMessageAck)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RouteMessageAck(::google::protobuf::internal::ConstantInitialized); + + inline RouteMessageAck(const RouteMessageAck& from) : RouteMessageAck(nullptr, from) {} + inline RouteMessageAck(RouteMessageAck&& from) noexcept + : RouteMessageAck(nullptr, ::std::move(from)) {} inline RouteMessageAck& operator=(const RouteMessageAck& from) { CopyFrom(from); return *this; } inline RouteMessageAck& operator=(RouteMessageAck&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1428,47 +1466,35 @@ class RouteMessageAck final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RouteMessageAck& default_instance() { - return *internal_default_instance(); - } - static inline const RouteMessageAck* internal_default_instance() { - return reinterpret_cast( - &_RouteMessageAck_default_instance_); + return *reinterpret_cast( + &_RouteMessageAck_default_instance_); } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(RouteMessageAck& a, RouteMessageAck& b) { - a.Swap(&b); - } - inline void Swap(RouteMessageAck* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(RouteMessageAck& a, RouteMessageAck& b) { a.Swap(&b); } + inline void Swap(RouteMessageAck* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RouteMessageAck* other) { + void UnsafeArenaSwap(RouteMessageAck* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1476,33 +1502,40 @@ class RouteMessageAck final : // implements Message ---------------------------------------------- - RouteMessageAck* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RouteMessageAck* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RouteMessageAck* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "RouteMessageAck"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RouteMessageAck* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "RouteMessageAck"; } + + explicit RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageAck& from); + RouteMessageAck( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RouteMessageAck&& from) noexcept + : RouteMessageAck(arena) { + *this = ::std::move(from); } - protected: - explicit RouteMessageAck(::google::protobuf::Arena* arena); - RouteMessageAck(::google::protobuf::Arena* arena, const RouteMessageAck& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 2, kErrorFieldNumber = 4, @@ -1511,69 +1544,72 @@ class RouteMessageAck final : }; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // string error = 4; void clear_error() ; - const std::string& error() const; - template + 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); + ::std::string* PROTOBUF_NONNULL mutable_error(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_error(); + void set_allocated_error(::std::string* PROTOBUF_NULLABLE 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(); + const ::std::string& _internal_error() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_error(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_error(); public: // .PeerDescriptor sourcePeer = 1; bool has_sourcepeer() const; void clear_sourcepeer() ; const ::PeerDescriptor& sourcepeer() const; - PROTOBUF_NODISCARD ::PeerDescriptor* release_sourcepeer(); - ::PeerDescriptor* mutable_sourcepeer(); - void set_allocated_sourcepeer(::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeer(::PeerDescriptor* value); - ::PeerDescriptor* unsafe_arena_release_sourcepeer(); + [[nodiscard]] ::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeer(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeer(); + void set_allocated_sourcepeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + ::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeer(); private: const ::PeerDescriptor& _internal_sourcepeer() const; - ::PeerDescriptor* _internal_mutable_sourcepeer(); + ::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeer(); public: // .PeerDescriptor destinationPeer = 3; bool has_destinationpeer() const; void clear_destinationpeer() ; const ::PeerDescriptor& destinationpeer() const; - PROTOBUF_NODISCARD ::PeerDescriptor* release_destinationpeer(); - ::PeerDescriptor* mutable_destinationpeer(); - void set_allocated_destinationpeer(::PeerDescriptor* value); - void unsafe_arena_set_allocated_destinationpeer(::PeerDescriptor* value); - ::PeerDescriptor* unsafe_arena_release_destinationpeer(); + [[nodiscard]] ::PeerDescriptor* PROTOBUF_NULLABLE release_destinationpeer(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_destinationpeer(); + void set_allocated_destinationpeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_destinationpeer(::PeerDescriptor* PROTOBUF_NULLABLE value); + ::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_destinationpeer(); private: const ::PeerDescriptor& _internal_destinationpeer() const; - ::PeerDescriptor* _internal_mutable_destinationpeer(); + ::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_destinationpeer(); public: // @@protoc_insertion_point(class_scope:RouteMessageAck) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 2, 38, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1582,51 +1618,55 @@ class RouteMessageAck final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RouteMessageAck& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr error_; - ::PeerDescriptor* sourcepeer_; - ::PeerDescriptor* destinationpeer_; + ::PeerDescriptor* PROTOBUF_NULLABLE sourcepeer_; + ::PeerDescriptor* PROTOBUF_NULLABLE destinationpeer_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_; +// ------------------------------------------------------------------- -class ClosestPeersResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ClosestPeersResponse) */ { +class ClosestPeersResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ClosestPeersResponse) */ { public: inline ClosestPeersResponse() : ClosestPeersResponse(nullptr) {} - ~ClosestPeersResponse() override; - template - explicit PROTOBUF_CONSTEXPR ClosestPeersResponse(::google::protobuf::internal::ConstantInitialized); + ~ClosestPeersResponse() PROTOBUF_FINAL; - inline ClosestPeersResponse(const ClosestPeersResponse& from) - : ClosestPeersResponse(nullptr, from) {} - ClosestPeersResponse(ClosestPeersResponse&& from) noexcept - : ClosestPeersResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestPeersResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestPeersResponse)); } +#endif + template + explicit PROTOBUF_CONSTEXPR ClosestPeersResponse(::google::protobuf::internal::ConstantInitialized); + + inline ClosestPeersResponse(const ClosestPeersResponse& from) : ClosestPeersResponse(nullptr, from) {} + inline ClosestPeersResponse(ClosestPeersResponse&& from) noexcept + : ClosestPeersResponse(nullptr, ::std::move(from)) {} inline ClosestPeersResponse& operator=(const ClosestPeersResponse& from) { CopyFrom(from); return *this; } inline ClosestPeersResponse& operator=(ClosestPeersResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1638,47 +1678,35 @@ class ClosestPeersResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestPeersResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestPeersResponse* internal_default_instance() { - return reinterpret_cast( - &_ClosestPeersResponse_default_instance_); + return *reinterpret_cast( + &_ClosestPeersResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(ClosestPeersResponse& a, ClosestPeersResponse& b) { - a.Swap(&b); - } - inline void Swap(ClosestPeersResponse* other) { + static constexpr int kIndexInFileMessages = 5; + friend void swap(ClosestPeersResponse& a, ClosestPeersResponse& b) { a.Swap(&b); } + inline void Swap(ClosestPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestPeersResponse* other) { + void UnsafeArenaSwap(ClosestPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1686,33 +1714,40 @@ class ClosestPeersResponse final : // implements Message ---------------------------------------------- - ClosestPeersResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestPeersResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestPeersResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ClosestPeersResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestPeersResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ClosestPeersResponse"; } + + explicit ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersResponse& from); + ClosestPeersResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestPeersResponse&& from) noexcept + : ClosestPeersResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestPeersResponse(::google::protobuf::Arena* arena); - ClosestPeersResponse(::google::protobuf::Arena* arena, const ClosestPeersResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kPeersFieldNumber = 1, kRequestIdFieldNumber = 2, @@ -1724,36 +1759,39 @@ class ClosestPeersResponse final : public: void clear_peers() ; - ::PeerDescriptor* mutable_peers(int index); - ::google::protobuf::RepeatedPtrField< ::PeerDescriptor >* - mutable_peers(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_peers(int index); + ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* PROTOBUF_NONNULL mutable_peers(); + private: const ::google::protobuf::RepeatedPtrField<::PeerDescriptor>& _internal_peers() const; - ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* _internal_mutable_peers(); + ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_peers(); public: const ::PeerDescriptor& peers(int index) const; - ::PeerDescriptor* add_peers(); - const ::google::protobuf::RepeatedPtrField< ::PeerDescriptor >& - peers() const; + ::PeerDescriptor* PROTOBUF_NONNULL add_peers(); + const ::google::protobuf::RepeatedPtrField<::PeerDescriptor>& peers() const; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:ClosestPeersResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 38, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1762,48 +1800,53 @@ class ClosestPeersResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestPeersResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::PeerDescriptor > peers_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; -};// ------------------------------------------------------------------- +}; -class ClosestPeersRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ClosestPeersRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_; +// ------------------------------------------------------------------- + +class ClosestPeersRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ClosestPeersRequest) */ { public: inline ClosestPeersRequest() : ClosestPeersRequest(nullptr) {} - ~ClosestPeersRequest() override; - template - explicit PROTOBUF_CONSTEXPR ClosestPeersRequest(::google::protobuf::internal::ConstantInitialized); + ~ClosestPeersRequest() PROTOBUF_FINAL; - inline ClosestPeersRequest(const ClosestPeersRequest& from) - : ClosestPeersRequest(nullptr, from) {} - ClosestPeersRequest(ClosestPeersRequest&& from) noexcept - : ClosestPeersRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestPeersRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestPeersRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestPeersRequest(::google::protobuf::internal::ConstantInitialized); + inline ClosestPeersRequest(const ClosestPeersRequest& from) : ClosestPeersRequest(nullptr, from) {} + inline ClosestPeersRequest(ClosestPeersRequest&& from) noexcept + : ClosestPeersRequest(nullptr, ::std::move(from)) {} inline ClosestPeersRequest& operator=(const ClosestPeersRequest& from) { CopyFrom(from); return *this; } inline ClosestPeersRequest& operator=(ClosestPeersRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1815,47 +1858,35 @@ class ClosestPeersRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestPeersRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ClosestPeersRequest_default_instance_); } - static inline const ClosestPeersRequest* internal_default_instance() { - return reinterpret_cast( - &_ClosestPeersRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(ClosestPeersRequest& a, ClosestPeersRequest& b) { - a.Swap(&b); - } - inline void Swap(ClosestPeersRequest* other) { + static constexpr int kIndexInFileMessages = 4; + friend void swap(ClosestPeersRequest& a, ClosestPeersRequest& b) { a.Swap(&b); } + inline void Swap(ClosestPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestPeersRequest* other) { + void UnsafeArenaSwap(ClosestPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1863,71 +1894,82 @@ class ClosestPeersRequest final : // implements Message ---------------------------------------------- - ClosestPeersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestPeersRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestPeersRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ClosestPeersRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestPeersRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ClosestPeersRequest"; } + + explicit ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersRequest& from); + ClosestPeersRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestPeersRequest&& from) noexcept + : ClosestPeersRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestPeersRequest(::google::protobuf::Arena* arena); - ClosestPeersRequest(::google::protobuf::Arena* arena, const ClosestPeersRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 2, kPeerDescriptorFieldNumber = 1, }; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // .PeerDescriptor peerDescriptor = 1; bool has_peerdescriptor() const; void clear_peerdescriptor() ; const ::PeerDescriptor& peerdescriptor() const; - PROTOBUF_NODISCARD ::PeerDescriptor* release_peerdescriptor(); - ::PeerDescriptor* mutable_peerdescriptor(); - void set_allocated_peerdescriptor(::PeerDescriptor* value); - void unsafe_arena_set_allocated_peerdescriptor(::PeerDescriptor* value); - ::PeerDescriptor* unsafe_arena_release_peerdescriptor(); + [[nodiscard]] ::PeerDescriptor* PROTOBUF_NULLABLE release_peerdescriptor(); + ::PeerDescriptor* PROTOBUF_NONNULL mutable_peerdescriptor(); + void set_allocated_peerdescriptor(::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_peerdescriptor(::PeerDescriptor* PROTOBUF_NULLABLE value); + ::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_peerdescriptor(); private: const ::PeerDescriptor& _internal_peerdescriptor() const; - ::PeerDescriptor* _internal_mutable_peerdescriptor(); + ::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_peerdescriptor(); public: // @@protoc_insertion_point(class_scope:ClosestPeersRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 37, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1936,23 +1978,26 @@ class ClosestPeersRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestPeersRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - ::PeerDescriptor* peerdescriptor_; + ::PeerDescriptor* PROTOBUF_NULLABLE peerdescriptor_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_TestProtos_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_; + // =================================================================== @@ -1971,17 +2016,18 @@ class ClosestPeersRequest final : // .PeerDescriptor sourcePeer = 1; inline bool RouteMessageWrapper::has_sourcepeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.sourcepeer_ != nullptr); return value; } inline void RouteMessageWrapper::clear_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ != nullptr) _impl_.sourcepeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::PeerDescriptor& RouteMessageWrapper::_internal_sourcepeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::PeerDescriptor* p = _impl_.sourcepeer_; return p != nullptr ? *p : reinterpret_cast(::_PeerDescriptor_default_instance_); } @@ -1989,76 +2035,78 @@ inline const ::PeerDescriptor& RouteMessageWrapper::sourcepeer() const ABSL_ATTR // @@protoc_insertion_point(field_get:RouteMessageWrapper.sourcePeer) return _internal_sourcepeer(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_sourcepeer(::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_sourcepeer( + ::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } _impl_.sourcepeer_ = reinterpret_cast<::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:RouteMessageWrapper.sourcePeer) } -inline ::PeerDescriptor* RouteMessageWrapper::release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::PeerDescriptor* released = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::PeerDescriptor* RouteMessageWrapper::unsafe_arena_release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageWrapper.sourcePeer) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::PeerDescriptor* temp = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; return temp; } -inline ::PeerDescriptor* RouteMessageWrapper::_internal_mutable_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ == nullptr) { - auto* p = CreateMaybeMessage<::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::PeerDescriptor>(GetArena()); _impl_.sourcepeer_ = reinterpret_cast<::PeerDescriptor*>(p); } return _impl_.sourcepeer_; } -inline ::PeerDescriptor* RouteMessageWrapper::mutable_sourcepeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_sourcepeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::PeerDescriptor* _msg = _internal_mutable_sourcepeer(); // @@protoc_insertion_point(field_mutable:RouteMessageWrapper.sourcePeer) return _msg; } -inline void RouteMessageWrapper::set_allocated_sourcepeer(::PeerDescriptor* value) { +inline void RouteMessageWrapper::set_allocated_sourcepeer(::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::PeerDescriptor*>(_impl_.sourcepeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.sourcepeer_ = reinterpret_cast<::PeerDescriptor*>(value); @@ -2067,70 +2115,83 @@ inline void RouteMessageWrapper::set_allocated_sourcepeer(::PeerDescriptor* valu // string requestId = 2; inline void RouteMessageWrapper::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RouteMessageWrapper::requestid() const +inline const ::std::string& RouteMessageWrapper::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:RouteMessageWrapper.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:RouteMessageWrapper.requestId) } -inline std::string* RouteMessageWrapper::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:RouteMessageWrapper.requestId) return _s; } -inline const std::string& RouteMessageWrapper::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageWrapper::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RouteMessageWrapper::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageWrapper::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RouteMessageWrapper::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RouteMessageWrapper::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageWrapper::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageWrapper.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RouteMessageWrapper::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:RouteMessageWrapper.requestId) } // .PeerDescriptor destinationPeer = 3; inline bool RouteMessageWrapper::has_destinationpeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.destinationpeer_ != nullptr); return value; } inline void RouteMessageWrapper::clear_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.destinationpeer_ != nullptr) _impl_.destinationpeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::PeerDescriptor& RouteMessageWrapper::_internal_destinationpeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::PeerDescriptor* p = _impl_.destinationpeer_; return p != nullptr ? *p : reinterpret_cast(::_PeerDescriptor_default_instance_); } @@ -2138,76 +2199,78 @@ inline const ::PeerDescriptor& RouteMessageWrapper::destinationpeer() const ABSL // @@protoc_insertion_point(field_get:RouteMessageWrapper.destinationPeer) return _internal_destinationpeer(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_destinationpeer(::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_destinationpeer( + ::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.destinationpeer_); } _impl_.destinationpeer_ = reinterpret_cast<::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:RouteMessageWrapper.destinationPeer) } -inline ::PeerDescriptor* RouteMessageWrapper::release_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::release_destinationpeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::PeerDescriptor* released = _impl_.destinationpeer_; _impl_.destinationpeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::PeerDescriptor* RouteMessageWrapper::unsafe_arena_release_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_destinationpeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageWrapper.destinationPeer) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::PeerDescriptor* temp = _impl_.destinationpeer_; _impl_.destinationpeer_ = nullptr; return temp; } -inline ::PeerDescriptor* RouteMessageWrapper::_internal_mutable_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_destinationpeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.destinationpeer_ == nullptr) { - auto* p = CreateMaybeMessage<::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::PeerDescriptor>(GetArena()); _impl_.destinationpeer_ = reinterpret_cast<::PeerDescriptor*>(p); } return _impl_.destinationpeer_; } -inline ::PeerDescriptor* RouteMessageWrapper::mutable_destinationpeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_destinationpeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::PeerDescriptor* _msg = _internal_mutable_destinationpeer(); // @@protoc_insertion_point(field_mutable:RouteMessageWrapper.destinationPeer) return _msg; } -inline void RouteMessageWrapper::set_allocated_destinationpeer(::PeerDescriptor* value) { +inline void RouteMessageWrapper::set_allocated_destinationpeer(::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::PeerDescriptor*>(_impl_.destinationpeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.destinationpeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.destinationpeer_ = reinterpret_cast<::PeerDescriptor*>(value); @@ -2216,17 +2279,18 @@ inline void RouteMessageWrapper::set_allocated_destinationpeer(::PeerDescriptor* // .PeerDescriptor previousPeer = 4; inline bool RouteMessageWrapper::has_previouspeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.previouspeer_ != nullptr); return value; } inline void RouteMessageWrapper::clear_previouspeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.previouspeer_ != nullptr) _impl_.previouspeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline const ::PeerDescriptor& RouteMessageWrapper::_internal_previouspeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::PeerDescriptor* p = _impl_.previouspeer_; return p != nullptr ? *p : reinterpret_cast(::_PeerDescriptor_default_instance_); } @@ -2234,76 +2298,78 @@ inline const ::PeerDescriptor& RouteMessageWrapper::previouspeer() const ABSL_AT // @@protoc_insertion_point(field_get:RouteMessageWrapper.previousPeer) return _internal_previouspeer(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_previouspeer(::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_previouspeer( + ::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.previouspeer_); } _impl_.previouspeer_ = reinterpret_cast<::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:RouteMessageWrapper.previousPeer) } -inline ::PeerDescriptor* RouteMessageWrapper::release_previouspeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::release_previouspeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::PeerDescriptor* released = _impl_.previouspeer_; _impl_.previouspeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::PeerDescriptor* RouteMessageWrapper::unsafe_arena_release_previouspeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_previouspeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageWrapper.previousPeer) - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::PeerDescriptor* temp = _impl_.previouspeer_; _impl_.previouspeer_ = nullptr; return temp; } -inline ::PeerDescriptor* RouteMessageWrapper::_internal_mutable_previouspeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_previouspeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.previouspeer_ == nullptr) { - auto* p = CreateMaybeMessage<::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::PeerDescriptor>(GetArena()); _impl_.previouspeer_ = reinterpret_cast<::PeerDescriptor*>(p); } return _impl_.previouspeer_; } -inline ::PeerDescriptor* RouteMessageWrapper::mutable_previouspeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_previouspeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::PeerDescriptor* _msg = _internal_mutable_previouspeer(); // @@protoc_insertion_point(field_mutable:RouteMessageWrapper.previousPeer) return _msg; } -inline void RouteMessageWrapper::set_allocated_previouspeer(::PeerDescriptor* value) { +inline void RouteMessageWrapper::set_allocated_previouspeer(::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::PeerDescriptor*>(_impl_.previouspeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.previouspeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::PeerDescriptor*>(value)->GetArena(); + ::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] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.previouspeer_ = reinterpret_cast<::PeerDescriptor*>(value); @@ -2312,54 +2378,66 @@ inline void RouteMessageWrapper::set_allocated_previouspeer(::PeerDescriptor* va // bytes message = 5; inline void RouteMessageWrapper::clear_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.message_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RouteMessageWrapper::message() const +inline const ::std::string& RouteMessageWrapper::message() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:RouteMessageWrapper.message) return _internal_message(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_message(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_message(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.message_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:RouteMessageWrapper.message) } -inline std::string* RouteMessageWrapper::mutable_message() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_message(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_message() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_message(); // @@protoc_insertion_point(field_mutable:RouteMessageWrapper.message) return _s; } -inline const std::string& RouteMessageWrapper::_internal_message() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageWrapper::_internal_message() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.message_.Get(); } -inline void RouteMessageWrapper::_internal_set_message(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageWrapper::_internal_set_message(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.message_.Set(value, GetArena()); } -inline std::string* RouteMessageWrapper::_internal_mutable_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.message_.Mutable( GetArena()); } -inline std::string* RouteMessageWrapper::release_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageWrapper::release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageWrapper.message) - return _impl_.message_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.message_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.message_.Set("", GetArena()); + } + return released; } -inline void RouteMessageWrapper::set_allocated_message(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.message_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:RouteMessageWrapper.message) } @@ -2369,17 +2447,18 @@ inline void RouteMessageWrapper::set_allocated_message(std::string* value) { // .PeerDescriptor sourcePeer = 1; inline bool RouteMessageAck::has_sourcepeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.sourcepeer_ != nullptr); return value; } inline void RouteMessageAck::clear_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ != nullptr) _impl_.sourcepeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::PeerDescriptor& RouteMessageAck::_internal_sourcepeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::PeerDescriptor* p = _impl_.sourcepeer_; return p != nullptr ? *p : reinterpret_cast(::_PeerDescriptor_default_instance_); } @@ -2387,76 +2466,78 @@ inline const ::PeerDescriptor& RouteMessageAck::sourcepeer() const ABSL_ATTRIBUT // @@protoc_insertion_point(field_get:RouteMessageAck.sourcePeer) return _internal_sourcepeer(); } -inline void RouteMessageAck::unsafe_arena_set_allocated_sourcepeer(::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageAck::unsafe_arena_set_allocated_sourcepeer( + ::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } _impl_.sourcepeer_ = reinterpret_cast<::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:RouteMessageAck.sourcePeer) } -inline ::PeerDescriptor* RouteMessageAck::release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageAck::release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::PeerDescriptor* released = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::PeerDescriptor* RouteMessageAck::unsafe_arena_release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageAck::unsafe_arena_release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageAck.sourcePeer) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::PeerDescriptor* temp = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; return temp; } -inline ::PeerDescriptor* RouteMessageAck::_internal_mutable_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageAck::_internal_mutable_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ == nullptr) { - auto* p = CreateMaybeMessage<::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::PeerDescriptor>(GetArena()); _impl_.sourcepeer_ = reinterpret_cast<::PeerDescriptor*>(p); } return _impl_.sourcepeer_; } -inline ::PeerDescriptor* RouteMessageAck::mutable_sourcepeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageAck::mutable_sourcepeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::PeerDescriptor* _msg = _internal_mutable_sourcepeer(); // @@protoc_insertion_point(field_mutable:RouteMessageAck.sourcePeer) return _msg; } -inline void RouteMessageAck::set_allocated_sourcepeer(::PeerDescriptor* value) { +inline void RouteMessageAck::set_allocated_sourcepeer(::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::PeerDescriptor*>(_impl_.sourcepeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.sourcepeer_ = reinterpret_cast<::PeerDescriptor*>(value); @@ -2465,70 +2546,83 @@ inline void RouteMessageAck::set_allocated_sourcepeer(::PeerDescriptor* value) { // string requestId = 2; inline void RouteMessageAck::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RouteMessageAck::requestid() const +inline const ::std::string& RouteMessageAck::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:RouteMessageAck.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:RouteMessageAck.requestId) } -inline std::string* RouteMessageAck::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:RouteMessageAck.requestId) return _s; } -inline const std::string& RouteMessageAck::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageAck::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RouteMessageAck::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageAck::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RouteMessageAck::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RouteMessageAck::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageAck::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageAck.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RouteMessageAck::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageAck::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:RouteMessageAck.requestId) } // .PeerDescriptor destinationPeer = 3; inline bool RouteMessageAck::has_destinationpeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.destinationpeer_ != nullptr); return value; } inline void RouteMessageAck::clear_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.destinationpeer_ != nullptr) _impl_.destinationpeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::PeerDescriptor& RouteMessageAck::_internal_destinationpeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::PeerDescriptor* p = _impl_.destinationpeer_; return p != nullptr ? *p : reinterpret_cast(::_PeerDescriptor_default_instance_); } @@ -2536,76 +2630,78 @@ inline const ::PeerDescriptor& RouteMessageAck::destinationpeer() const ABSL_ATT // @@protoc_insertion_point(field_get:RouteMessageAck.destinationPeer) return _internal_destinationpeer(); } -inline void RouteMessageAck::unsafe_arena_set_allocated_destinationpeer(::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageAck::unsafe_arena_set_allocated_destinationpeer( + ::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.destinationpeer_); } _impl_.destinationpeer_ = reinterpret_cast<::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:RouteMessageAck.destinationPeer) } -inline ::PeerDescriptor* RouteMessageAck::release_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageAck::release_destinationpeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::PeerDescriptor* released = _impl_.destinationpeer_; _impl_.destinationpeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::PeerDescriptor* RouteMessageAck::unsafe_arena_release_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageAck::unsafe_arena_release_destinationpeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageAck.destinationPeer) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::PeerDescriptor* temp = _impl_.destinationpeer_; _impl_.destinationpeer_ = nullptr; return temp; } -inline ::PeerDescriptor* RouteMessageAck::_internal_mutable_destinationpeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageAck::_internal_mutable_destinationpeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.destinationpeer_ == nullptr) { - auto* p = CreateMaybeMessage<::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::PeerDescriptor>(GetArena()); _impl_.destinationpeer_ = reinterpret_cast<::PeerDescriptor*>(p); } return _impl_.destinationpeer_; } -inline ::PeerDescriptor* RouteMessageAck::mutable_destinationpeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::PeerDescriptor* PROTOBUF_NONNULL RouteMessageAck::mutable_destinationpeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::PeerDescriptor* _msg = _internal_mutable_destinationpeer(); // @@protoc_insertion_point(field_mutable:RouteMessageAck.destinationPeer) return _msg; } -inline void RouteMessageAck::set_allocated_destinationpeer(::PeerDescriptor* value) { +inline void RouteMessageAck::set_allocated_destinationpeer(::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::PeerDescriptor*>(_impl_.destinationpeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.destinationpeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.destinationpeer_ = reinterpret_cast<::PeerDescriptor*>(value); @@ -2614,54 +2710,66 @@ inline void RouteMessageAck::set_allocated_destinationpeer(::PeerDescriptor* val // string error = 4; inline void RouteMessageAck::clear_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RouteMessageAck::error() const +inline const ::std::string& RouteMessageAck::error() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:RouteMessageAck.error) return _internal_error(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_error(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_error(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.error_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:RouteMessageAck.error) } -inline std::string* RouteMessageAck::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_error(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::mutable_error() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_error(); // @@protoc_insertion_point(field_mutable:RouteMessageAck.error) return _s; } -inline const std::string& RouteMessageAck::_internal_error() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageAck::_internal_error() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.error_.Get(); } -inline void RouteMessageAck::_internal_set_error(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageAck::_internal_set_error(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_.Set(value, GetArena()); } -inline std::string* RouteMessageAck::_internal_mutable_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::_internal_mutable_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.error_.Mutable( GetArena()); } -inline std::string* RouteMessageAck::release_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageAck::release_error() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:RouteMessageAck.error) - return _impl_.error_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.error_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.error_.Set("", GetArena()); + } + return released; } -inline void RouteMessageAck::set_allocated_error(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageAck::set_allocated_error(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.error_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.error_.IsDefault()) { - _impl_.error_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:RouteMessageAck.error) } @@ -2671,54 +2779,66 @@ inline void RouteMessageAck::set_allocated_error(std::string* value) { // string requestId = 1; inline void PingRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PingRequest::requestid() const +inline const ::std::string& PingRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:PingRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void PingRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PingRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:PingRequest.requestId) } -inline std::string* PingRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL PingRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:PingRequest.requestId) return _s; } -inline const std::string& PingRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PingRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void PingRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PingRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* PingRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PingRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* PingRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PingRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:PingRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void PingRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PingRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:PingRequest.requestId) } @@ -2728,54 +2848,66 @@ inline void PingRequest::set_allocated_requestid(std::string* value) { // string requestId = 1; inline void PingResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PingResponse::requestid() const +inline const ::std::string& PingResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:PingResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void PingResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PingResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:PingResponse.requestId) } -inline std::string* PingResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL PingResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:PingResponse.requestId) return _s; } -inline const std::string& PingResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PingResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void PingResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PingResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* PingResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PingResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* PingResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PingResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:PingResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void PingResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PingResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:PingResponse.requestId) } @@ -2785,17 +2917,18 @@ inline void PingResponse::set_allocated_requestid(std::string* value) { // .PeerDescriptor peerDescriptor = 1; inline bool ClosestPeersRequest::has_peerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.peerdescriptor_ != nullptr); return value; } inline void ClosestPeersRequest::clear_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peerdescriptor_ != nullptr) _impl_.peerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::PeerDescriptor& ClosestPeersRequest::_internal_peerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::PeerDescriptor* p = _impl_.peerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::_PeerDescriptor_default_instance_); } @@ -2803,76 +2936,78 @@ inline const ::PeerDescriptor& ClosestPeersRequest::peerdescriptor() const ABSL_ // @@protoc_insertion_point(field_get:ClosestPeersRequest.peerDescriptor) return _internal_peerdescriptor(); } -inline void ClosestPeersRequest::unsafe_arena_set_allocated_peerdescriptor(::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersRequest::unsafe_arena_set_allocated_peerdescriptor( + ::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peerdescriptor_); } _impl_.peerdescriptor_ = reinterpret_cast<::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ClosestPeersRequest.peerDescriptor) } -inline ::PeerDescriptor* ClosestPeersRequest::release_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE ClosestPeersRequest::release_peerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::PeerDescriptor* released = _impl_.peerdescriptor_; _impl_.peerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::PeerDescriptor* ClosestPeersRequest::unsafe_arena_release_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::PeerDescriptor* PROTOBUF_NULLABLE ClosestPeersRequest::unsafe_arena_release_peerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ClosestPeersRequest.peerDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::PeerDescriptor* temp = _impl_.peerdescriptor_; _impl_.peerdescriptor_ = nullptr; return temp; } -inline ::PeerDescriptor* ClosestPeersRequest::_internal_mutable_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersRequest::_internal_mutable_peerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::PeerDescriptor>(GetArena()); _impl_.peerdescriptor_ = reinterpret_cast<::PeerDescriptor*>(p); } return _impl_.peerdescriptor_; } -inline ::PeerDescriptor* ClosestPeersRequest::mutable_peerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersRequest::mutable_peerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::PeerDescriptor* _msg = _internal_mutable_peerdescriptor(); // @@protoc_insertion_point(field_mutable:ClosestPeersRequest.peerDescriptor) return _msg; } -inline void ClosestPeersRequest::set_allocated_peerdescriptor(::PeerDescriptor* value) { +inline void ClosestPeersRequest::set_allocated_peerdescriptor(::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::PeerDescriptor*>(_impl_.peerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.peerdescriptor_ = reinterpret_cast<::PeerDescriptor*>(value); @@ -2881,54 +3016,66 @@ inline void ClosestPeersRequest::set_allocated_peerdescriptor(::PeerDescriptor* // string requestId = 2; inline void ClosestPeersRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ClosestPeersRequest::requestid() const +inline const ::std::string& ClosestPeersRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:ClosestPeersRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:ClosestPeersRequest.requestId) } -inline std::string* ClosestPeersRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:ClosestPeersRequest.requestId) return _s; } -inline const std::string& ClosestPeersRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestPeersRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestPeersRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestPeersRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ClosestPeersRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:ClosestPeersRequest.requestId) } @@ -2944,18 +3091,21 @@ inline int ClosestPeersResponse::peers_size() const { return _internal_peers_size(); } inline void ClosestPeersResponse::clear_peers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.peers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::PeerDescriptor* ClosestPeersResponse::mutable_peers(int index) +inline ::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersResponse::mutable_peers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:ClosestPeersResponse.peers) return _internal_mutable_peers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* ClosestPeersResponse::mutable_peers() +inline ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* PROTOBUF_NONNULL ClosestPeersResponse::mutable_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:ClosestPeersResponse.peers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_peers(); } inline const ::PeerDescriptor& ClosestPeersResponse::peers(int index) const @@ -2963,9 +3113,13 @@ inline const ::PeerDescriptor& ClosestPeersResponse::peers(int index) const // @@protoc_insertion_point(field_get:ClosestPeersResponse.peers) return _internal_peers().Get(index); } -inline ::PeerDescriptor* ClosestPeersResponse::add_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::PeerDescriptor* _add = _internal_mutable_peers()->Add(); +inline ::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersResponse::add_peers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::PeerDescriptor* _add = + _internal_mutable_peers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:ClosestPeersResponse.peers) return _add; } @@ -2976,65 +3130,77 @@ inline const ::google::protobuf::RepeatedPtrField<::PeerDescriptor>& ClosestPeer } inline const ::google::protobuf::RepeatedPtrField<::PeerDescriptor>& ClosestPeersResponse::_internal_peers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.peers_; } -inline ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::PeerDescriptor>* PROTOBUF_NONNULL ClosestPeersResponse::_internal_mutable_peers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.peers_; } // string requestId = 2; inline void ClosestPeersResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestPeersResponse::requestid() const +inline const ::std::string& ClosestPeersResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:ClosestPeersResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:ClosestPeersResponse.requestId) } -inline std::string* ClosestPeersResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:ClosestPeersResponse.requestId) return _s; } -inline const std::string& ClosestPeersResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestPeersResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestPeersResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestPeersResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ClosestPeersResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:ClosestPeersResponse.requestId) } @@ -3044,61 +3210,75 @@ inline void ClosestPeersResponse::set_allocated_requestid(std::string* value) { // bytes nodeId = 1; inline void PeerDescriptor::clear_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PeerDescriptor::nodeid() const +inline const ::std::string& PeerDescriptor::nodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:PeerDescriptor.nodeId) return _internal_nodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_nodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_nodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.nodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:PeerDescriptor.nodeId) } -inline std::string* PeerDescriptor::mutable_nodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nodeid(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_nodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_nodeid(); // @@protoc_insertion_point(field_mutable:PeerDescriptor.nodeId) return _s; } -inline const std::string& PeerDescriptor::_internal_nodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_nodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nodeid_.Get(); } -inline void PeerDescriptor::_internal_set_nodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PeerDescriptor::_internal_set_nodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nodeid_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:PeerDescriptor.nodeId) - return _impl_.nodeid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.nodeid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nodeid_.Set("", GetArena()); + } + return released; } -inline void PeerDescriptor::set_allocated_nodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.nodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nodeid_.IsDefault()) { - _impl_.nodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nodeid_.IsDefault()) { + _impl_.nodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:PeerDescriptor.nodeId) } // .NodeType type = 2; inline void PeerDescriptor::clear_type() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline ::NodeType PeerDescriptor::type() const { // @@protoc_insertion_point(field_get:PeerDescriptor.type) @@ -3106,31 +3286,32 @@ inline ::NodeType PeerDescriptor::type() const { } inline void PeerDescriptor::set_type(::NodeType value) { _internal_set_type(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:PeerDescriptor.type) } inline ::NodeType PeerDescriptor::_internal_type() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::NodeType>(_impl_.type_); } inline void PeerDescriptor::_internal_set_type(::NodeType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = value; } // .ConnectivityMethod udp = 3; inline bool PeerDescriptor::has_udp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.udp_ != nullptr); return value; } inline void PeerDescriptor::clear_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.udp_ != nullptr) _impl_.udp_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::ConnectivityMethod& PeerDescriptor::_internal_udp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::ConnectivityMethod* p = _impl_.udp_; return p != nullptr ? *p : reinterpret_cast(::_ConnectivityMethod_default_instance_); } @@ -3138,76 +3319,78 @@ inline const ::ConnectivityMethod& PeerDescriptor::udp() const ABSL_ATTRIBUTE_LI // @@protoc_insertion_point(field_get:PeerDescriptor.udp) return _internal_udp(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_udp(::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_udp( + ::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.udp_); } _impl_.udp_ = reinterpret_cast<::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PeerDescriptor.udp) } -inline ::ConnectivityMethod* PeerDescriptor::release_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::ConnectivityMethod* released = _impl_.udp_; _impl_.udp_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:PeerDescriptor.udp) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::ConnectivityMethod* temp = _impl_.udp_; _impl_.udp_ = nullptr; return temp; } -inline ::ConnectivityMethod* PeerDescriptor::_internal_mutable_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.udp_ == nullptr) { - auto* p = CreateMaybeMessage<::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::ConnectivityMethod>(GetArena()); _impl_.udp_ = reinterpret_cast<::ConnectivityMethod*>(p); } return _impl_.udp_; } -inline ::ConnectivityMethod* PeerDescriptor::mutable_udp() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_udp() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::ConnectivityMethod* _msg = _internal_mutable_udp(); // @@protoc_insertion_point(field_mutable:PeerDescriptor.udp) return _msg; } -inline void PeerDescriptor::set_allocated_udp(::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_udp(::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::ConnectivityMethod*>(_impl_.udp_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.udp_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::ConnectivityMethod*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.udp_ = reinterpret_cast<::ConnectivityMethod*>(value); @@ -3216,17 +3399,18 @@ inline void PeerDescriptor::set_allocated_udp(::ConnectivityMethod* value) { // .ConnectivityMethod tcp = 4; inline bool PeerDescriptor::has_tcp() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.tcp_ != nullptr); return value; } inline void PeerDescriptor::clear_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.tcp_ != nullptr) _impl_.tcp_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::ConnectivityMethod& PeerDescriptor::_internal_tcp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::ConnectivityMethod* p = _impl_.tcp_; return p != nullptr ? *p : reinterpret_cast(::_ConnectivityMethod_default_instance_); } @@ -3234,76 +3418,78 @@ inline const ::ConnectivityMethod& PeerDescriptor::tcp() const ABSL_ATTRIBUTE_LI // @@protoc_insertion_point(field_get:PeerDescriptor.tcp) return _internal_tcp(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_tcp(::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_tcp( + ::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tcp_); } _impl_.tcp_ = reinterpret_cast<::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PeerDescriptor.tcp) } -inline ::ConnectivityMethod* PeerDescriptor::release_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::ConnectivityMethod* released = _impl_.tcp_; _impl_.tcp_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:PeerDescriptor.tcp) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::ConnectivityMethod* temp = _impl_.tcp_; _impl_.tcp_ = nullptr; return temp; } -inline ::ConnectivityMethod* PeerDescriptor::_internal_mutable_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.tcp_ == nullptr) { - auto* p = CreateMaybeMessage<::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::ConnectivityMethod>(GetArena()); _impl_.tcp_ = reinterpret_cast<::ConnectivityMethod*>(p); } return _impl_.tcp_; } -inline ::ConnectivityMethod* PeerDescriptor::mutable_tcp() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_tcp() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::ConnectivityMethod* _msg = _internal_mutable_tcp(); // @@protoc_insertion_point(field_mutable:PeerDescriptor.tcp) return _msg; } -inline void PeerDescriptor::set_allocated_tcp(::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_tcp(::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::ConnectivityMethod*>(_impl_.tcp_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tcp_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::ConnectivityMethod*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.tcp_ = reinterpret_cast<::ConnectivityMethod*>(value); @@ -3312,17 +3498,18 @@ inline void PeerDescriptor::set_allocated_tcp(::ConnectivityMethod* value) { // .ConnectivityMethod websocket = 5; inline bool PeerDescriptor::has_websocket() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.websocket_ != nullptr); return value; } inline void PeerDescriptor::clear_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ != nullptr) _impl_.websocket_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::ConnectivityMethod& PeerDescriptor::_internal_websocket() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::ConnectivityMethod* p = _impl_.websocket_; return p != nullptr ? *p : reinterpret_cast(::_ConnectivityMethod_default_instance_); } @@ -3330,76 +3517,78 @@ inline const ::ConnectivityMethod& PeerDescriptor::websocket() const ABSL_ATTRIB // @@protoc_insertion_point(field_get:PeerDescriptor.websocket) return _internal_websocket(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_websocket(::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_websocket( + ::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } _impl_.websocket_ = reinterpret_cast<::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PeerDescriptor.websocket) } -inline ::ConnectivityMethod* PeerDescriptor::release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::ConnectivityMethod* released = _impl_.websocket_; _impl_.websocket_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:PeerDescriptor.websocket) - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::ConnectivityMethod* temp = _impl_.websocket_; _impl_.websocket_ = nullptr; return temp; } -inline ::ConnectivityMethod* PeerDescriptor::_internal_mutable_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ == nullptr) { - auto* p = CreateMaybeMessage<::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::ConnectivityMethod>(GetArena()); _impl_.websocket_ = reinterpret_cast<::ConnectivityMethod*>(p); } return _impl_.websocket_; } -inline ::ConnectivityMethod* PeerDescriptor::mutable_websocket() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_websocket() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::ConnectivityMethod* _msg = _internal_mutable_websocket(); // @@protoc_insertion_point(field_mutable:PeerDescriptor.websocket) return _msg; } -inline void PeerDescriptor::set_allocated_websocket(::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_websocket(::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::ConnectivityMethod*>(_impl_.websocket_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.websocket_ = reinterpret_cast<::ConnectivityMethod*>(value); @@ -3408,13 +3597,14 @@ inline void PeerDescriptor::set_allocated_websocket(::ConnectivityMethod* value) // optional bool openInternet = 6; inline bool PeerDescriptor::has_openinternet() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); return value; } inline void PeerDescriptor::clear_openinternet() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.openinternet_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline bool PeerDescriptor::openinternet() const { // @@protoc_insertion_point(field_get:PeerDescriptor.openInternet) @@ -3422,15 +3612,15 @@ inline bool PeerDescriptor::openinternet() const { } inline void PeerDescriptor::set_openinternet(bool value) { _internal_set_openinternet(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:PeerDescriptor.openInternet) } inline bool PeerDescriptor::_internal_openinternet() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.openinternet_; } inline void PeerDescriptor::_internal_set_openinternet(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000008u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.openinternet_ = value; } @@ -3440,8 +3630,10 @@ inline void PeerDescriptor::_internal_set_openinternet(bool value) { // uint32 port = 2; inline void ConnectivityMethod::clear_port() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::uint32_t ConnectivityMethod::port() const { // @@protoc_insertion_point(field_get:ConnectivityMethod.port) @@ -3449,68 +3641,80 @@ inline ::uint32_t ConnectivityMethod::port() const { } inline void ConnectivityMethod::set_port(::uint32_t value) { _internal_set_port(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:ConnectivityMethod.port) } inline ::uint32_t ConnectivityMethod::_internal_port() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.port_; } inline void ConnectivityMethod::_internal_set_port(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = value; } // string ip = 3; inline void ConnectivityMethod::clear_ip() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ip_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityMethod::ip() const +inline const ::std::string& ConnectivityMethod::ip() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:ConnectivityMethod.ip) return _internal_ip(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityMethod::set_ip(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityMethod::set_ip(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.ip_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:ConnectivityMethod.ip) } -inline std::string* ConnectivityMethod::mutable_ip() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_ip(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityMethod::mutable_ip() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_ip(); // @@protoc_insertion_point(field_mutable:ConnectivityMethod.ip) return _s; } -inline const std::string& ConnectivityMethod::_internal_ip() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityMethod::_internal_ip() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ip_.Get(); } -inline void ConnectivityMethod::_internal_set_ip(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityMethod::_internal_set_ip(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ip_.Set(value, GetArena()); } -inline std::string* ConnectivityMethod::_internal_mutable_ip() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityMethod::_internal_mutable_ip() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.ip_.Mutable( GetArena()); } -inline std::string* ConnectivityMethod::release_ip() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityMethod::release_ip() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ConnectivityMethod.ip) - return _impl_.ip_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.ip_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.ip_.Set("", GetArena()); + } + return released; } -inline void ConnectivityMethod::set_allocated_ip(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityMethod::set_allocated_ip(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.ip_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ip_.IsDefault()) { - _impl_.ip_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.ip_.IsDefault()) { + _impl_.ip_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:ConnectivityMethod.ip) } @@ -3520,72 +3724,70 @@ inline void ConnectivityMethod::set_allocated_ip(std::string* value) { // optional string someOptionalField = 1; inline bool OptionalRequest::has_someoptionalfield() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); return value; } inline void OptionalRequest::clear_someoptionalfield() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.someoptionalfield_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& OptionalRequest::someoptionalfield() const +inline const ::std::string& OptionalRequest::someoptionalfield() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:OptionalRequest.someOptionalField) return _internal_someoptionalfield(); } template -inline PROTOBUF_ALWAYS_INLINE void OptionalRequest::set_someoptionalfield(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void OptionalRequest::set_someoptionalfield(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.someoptionalfield_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:OptionalRequest.someOptionalField) } -inline std::string* OptionalRequest::mutable_someoptionalfield() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_someoptionalfield(); +inline ::std::string* PROTOBUF_NONNULL OptionalRequest::mutable_someoptionalfield() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_someoptionalfield(); // @@protoc_insertion_point(field_mutable:OptionalRequest.someOptionalField) return _s; } -inline const std::string& OptionalRequest::_internal_someoptionalfield() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& OptionalRequest::_internal_someoptionalfield() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.someoptionalfield_.Get(); } -inline void OptionalRequest::_internal_set_someoptionalfield(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void OptionalRequest::_internal_set_someoptionalfield(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.someoptionalfield_.Set(value, GetArena()); } -inline std::string* OptionalRequest::_internal_mutable_someoptionalfield() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL OptionalRequest::_internal_mutable_someoptionalfield() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.someoptionalfield_.Mutable( GetArena()); } -inline std::string* OptionalRequest::release_someoptionalfield() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE OptionalRequest::release_someoptionalfield() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:OptionalRequest.someOptionalField) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); auto* released = _impl_.someoptionalfield_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.someoptionalfield_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.someoptionalfield_.Set("", GetArena()); + } return released; } -inline void OptionalRequest::set_allocated_someoptionalfield(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void OptionalRequest::set_allocated_someoptionalfield(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.someoptionalfield_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.someoptionalfield_.IsDefault()) { - _impl_.someoptionalfield_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.someoptionalfield_.IsDefault()) { + _impl_.someoptionalfield_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:OptionalRequest.someOptionalField) } @@ -3595,72 +3797,70 @@ inline void OptionalRequest::set_allocated_someoptionalfield(std::string* value) // optional string someOptionalField = 1; inline bool OptionalResponse::has_someoptionalfield() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); return value; } inline void OptionalResponse::clear_someoptionalfield() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.someoptionalfield_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& OptionalResponse::someoptionalfield() const +inline const ::std::string& OptionalResponse::someoptionalfield() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:OptionalResponse.someOptionalField) return _internal_someoptionalfield(); } template -inline PROTOBUF_ALWAYS_INLINE void OptionalResponse::set_someoptionalfield(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void OptionalResponse::set_someoptionalfield(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.someoptionalfield_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:OptionalResponse.someOptionalField) } -inline std::string* OptionalResponse::mutable_someoptionalfield() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_someoptionalfield(); +inline ::std::string* PROTOBUF_NONNULL OptionalResponse::mutable_someoptionalfield() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_someoptionalfield(); // @@protoc_insertion_point(field_mutable:OptionalResponse.someOptionalField) return _s; } -inline const std::string& OptionalResponse::_internal_someoptionalfield() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& OptionalResponse::_internal_someoptionalfield() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.someoptionalfield_.Get(); } -inline void OptionalResponse::_internal_set_someoptionalfield(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void OptionalResponse::_internal_set_someoptionalfield(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.someoptionalfield_.Set(value, GetArena()); } -inline std::string* OptionalResponse::_internal_mutable_someoptionalfield() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL OptionalResponse::_internal_mutable_someoptionalfield() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.someoptionalfield_.Mutable( GetArena()); } -inline std::string* OptionalResponse::release_someoptionalfield() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE OptionalResponse::release_someoptionalfield() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:OptionalResponse.someOptionalField) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); auto* released = _impl_.someoptionalfield_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.someoptionalfield_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.someoptionalfield_.Set("", GetArena()); + } return released; } -inline void OptionalResponse::set_allocated_someoptionalfield(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void OptionalResponse::set_allocated_someoptionalfield(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.someoptionalfield_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.someoptionalfield_.IsDefault()) { - _impl_.someoptionalfield_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.someoptionalfield_.IsDefault()) { + _impl_.someoptionalfield_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:OptionalResponse.someOptionalField) } @@ -3677,7 +3877,7 @@ namespace protobuf { template <> struct is_proto_enum<::NodeType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::NodeType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::NodeType>() { return ::NodeType_descriptor(); } @@ -3688,4 +3888,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::NodeType>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_TestProtos_2eproto_2epb_2eh +#endif // TestProtos_2eproto_2epb_2eh diff --git a/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.cc b/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.cc index f338a14a..7e922aa6 100644 --- a/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.cc +++ b/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: WakeUpRpc.proto +// Protobuf C++ Version: 6.33.4 #include "WakeUpRpc.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" @@ -18,17 +23,24 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; inline constexpr WakeUpRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : reason_( + : _cached_size_{0}, + reason_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR WakeUpRequest::WakeUpRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WakeUpRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct WakeUpRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR WakeUpRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~WakeUpRequestDefaultTypeInternal() {} @@ -39,45 +51,41 @@ struct WakeUpRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WakeUpRequestDefaultTypeInternal _WakeUpRequest_default_instance_; -static ::_pb::Metadata file_level_metadata_WakeUpRpc_2eproto[1]; -static constexpr const ::_pb::EnumDescriptor** +static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_enum_descriptors_WakeUpRpc_2eproto = nullptr; -static constexpr const ::_pb::ServiceDescriptor** +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_WakeUpRpc_2eproto = nullptr; -const ::uint32_t TableStruct_WakeUpRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::WakeUpRequest, _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(::WakeUpRequest, _impl_.reason_), +const ::uint32_t + TableStruct_WakeUpRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::WakeUpRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::WakeUpRequest, _impl_.reason_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, -1, -1, sizeof(::WakeUpRequest)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::WakeUpRequest)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::_WakeUpRequest_default_instance_._instance, }; -const char descriptor_table_protodef_WakeUpRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_WakeUpRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n\017WakeUpRpc.proto\032\033google/protobuf/empty" ".proto\"\037\n\rWakeUpRequest\022\016\n\006reason\030\001 \001(\t2" "D\n\020WakeUpRpcService\0220\n\006wakeUp\022\016.WakeUpRe" "quest\032\026.google.protobuf.EmptyB\002H\002b\006proto" "3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_WakeUpRpc_2eproto_deps[1] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_WakeUpRpc_2eproto_deps[1] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::absl::once_flag descriptor_table_WakeUpRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_WakeUpRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_WakeUpRpc_2eproto = { false, false, 161, @@ -90,88 +98,162 @@ const ::_pbi::DescriptorTable descriptor_table_WakeUpRpc_2eproto = { schemas, file_default_instances, TableStruct_WakeUpRpc_2eproto::offsets, - file_level_metadata_WakeUpRpc_2eproto, file_level_enum_descriptors_WakeUpRpc_2eproto, file_level_service_descriptors_WakeUpRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_WakeUpRpc_2eproto_getter() { - return &descriptor_table_WakeUpRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_WakeUpRpc_2eproto(&descriptor_table_WakeUpRpc_2eproto); // =================================================================== class WakeUpRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(WakeUpRequest, _impl_._has_bits_); }; -WakeUpRequest::WakeUpRequest(::google::protobuf::Arena* arena) +WakeUpRequest::WakeUpRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, WakeUpRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:WakeUpRequest) } -inline PROTOBUF_NDEBUG_INLINE WakeUpRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : reason_(arena, from.reason_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE WakeUpRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::WakeUpRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + reason_(arena, from.reason_) {} WakeUpRequest::WakeUpRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WakeUpRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, WakeUpRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE WakeUpRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:WakeUpRequest) } -inline PROTOBUF_NDEBUG_INLINE WakeUpRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : reason_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE WakeUpRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + reason_(arena) {} -inline void WakeUpRequest::SharedCtor(::_pb::Arena* arena) { +inline void WakeUpRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } WakeUpRequest::~WakeUpRequest() { // @@protoc_insertion_point(destructor:WakeUpRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void WakeUpRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.reason_.Destroy(); - _impl_.~Impl_(); +inline void WakeUpRequest::SharedDtor(MessageLite& self) { + WakeUpRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.reason_.Destroy(); + this_._impl_.~Impl_(); } -::_pbi::CachedSize* WakeUpRequest::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL WakeUpRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) WakeUpRequest(arena); +} +constexpr auto WakeUpRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(WakeUpRequest), + alignof(WakeUpRequest)); } -void WakeUpRequest::InternalSwap(WakeUpRequest* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto WakeUpRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_WakeUpRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &WakeUpRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &WakeUpRequest::SharedDtor, + static_cast(&WakeUpRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(WakeUpRequest, _impl_._cached_size_), + false, + }, + &WakeUpRequest::kDescriptorMethods, + &descriptor_table_WakeUpRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull WakeUpRequest_class_data_ = + WakeUpRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +WakeUpRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WakeUpRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WakeUpRequest_class_data_.tc_table); + return WakeUpRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 28, 2> +WakeUpRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(WakeUpRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + WakeUpRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::WakeUpRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string reason = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(WakeUpRequest, _impl_.reason_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string reason = 1; + {PROTOBUF_FIELD_OFFSET(WakeUpRequest, _impl_.reason_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\15\6\0\0\0\0\0\0" + "WakeUpRequest" + "reason" + }}, +}; +void WakeUpRequest::InternalSwap(WakeUpRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata WakeUpRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_WakeUpRpc_2eproto_getter, &descriptor_table_WakeUpRpc_2eproto_once, - file_level_metadata_WakeUpRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) namespace google { @@ -179,4 +261,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_WakeUpRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.h b/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.h index 3b818f1e..68e54c38 100644 --- a/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.h +++ b/packages/streamr-proto-rpc/test/proto/WakeUpRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: WakeUpRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_WakeUpRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_WakeUpRpc_2eproto_2epb_2eh +#ifndef WakeUpRpc_2eproto_2epb_2eh +#define WakeUpRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,6 +24,7 @@ #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" @@ -44,7 +39,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -53,11 +49,13 @@ class AnyMetadata; struct TableStruct_WakeUpRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_WakeUpRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_WakeUpRpc_2eproto; +} // extern "C" class WakeUpRequest; struct WakeUpRequestDefaultTypeInternal; extern WakeUpRequestDefaultTypeInternal _WakeUpRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WakeUpRequest_class_data_; namespace google { namespace protobuf { } // namespace protobuf @@ -69,32 +67,32 @@ namespace protobuf { // ------------------------------------------------------------------- -class WakeUpRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:WakeUpRequest) */ { +class WakeUpRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:WakeUpRequest) */ { public: inline WakeUpRequest() : WakeUpRequest(nullptr) {} - ~WakeUpRequest() override; - template - explicit PROTOBUF_CONSTEXPR WakeUpRequest(::google::protobuf::internal::ConstantInitialized); + ~WakeUpRequest() PROTOBUF_FINAL; - inline WakeUpRequest(const WakeUpRequest& from) - : WakeUpRequest(nullptr, from) {} - WakeUpRequest(WakeUpRequest&& from) noexcept - : WakeUpRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WakeUpRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WakeUpRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR WakeUpRequest(::google::protobuf::internal::ConstantInitialized); + inline WakeUpRequest(const WakeUpRequest& from) : WakeUpRequest(nullptr, from) {} + inline WakeUpRequest(WakeUpRequest&& from) noexcept + : WakeUpRequest(nullptr, ::std::move(from)) {} inline WakeUpRequest& operator=(const WakeUpRequest& from) { CopyFrom(from); return *this; } inline WakeUpRequest& operator=(WakeUpRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -106,47 +104,35 @@ class WakeUpRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const WakeUpRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_WakeUpRequest_default_instance_); } - static inline const WakeUpRequest* internal_default_instance() { - return reinterpret_cast( - &_WakeUpRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(WakeUpRequest& a, WakeUpRequest& b) { - a.Swap(&b); - } - inline void Swap(WakeUpRequest* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(WakeUpRequest& a, WakeUpRequest& b) { a.Swap(&b); } + inline void Swap(WakeUpRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(WakeUpRequest* other) { + void UnsafeArenaSwap(WakeUpRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -154,55 +140,66 @@ class WakeUpRequest final : // implements Message ---------------------------------------------- - WakeUpRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + WakeUpRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(WakeUpRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "WakeUpRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WakeUpRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "WakeUpRequest"; } + + explicit WakeUpRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WakeUpRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WakeUpRequest& from); + WakeUpRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WakeUpRequest&& from) noexcept + : WakeUpRequest(arena) { + *this = ::std::move(from); } - protected: - explicit WakeUpRequest(::google::protobuf::Arena* arena); - WakeUpRequest(::google::protobuf::Arena* arena, const WakeUpRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kReasonFieldNumber = 1, }; // string reason = 1; void clear_reason() ; - const std::string& reason() const; - template + const ::std::string& reason() const; + template void set_reason(Arg_&& arg, Args_... args); - std::string* mutable_reason(); - PROTOBUF_NODISCARD std::string* release_reason(); - void set_allocated_reason(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_reason(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_reason(); + void set_allocated_reason(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_reason() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_reason( - const std::string& value); - std::string* _internal_mutable_reason(); + const ::std::string& _internal_reason() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_reason(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_reason(); public: // @@protoc_insertion_point(class_scope:WakeUpRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 28, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -211,21 +208,25 @@ class WakeUpRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WakeUpRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr reason_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_WakeUpRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull WakeUpRequest_class_data_; + // =================================================================== @@ -244,54 +245,66 @@ class WakeUpRequest final : // string reason = 1; inline void WakeUpRequest::clear_reason() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.reason_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& WakeUpRequest::reason() const +inline const ::std::string& WakeUpRequest::reason() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:WakeUpRequest.reason) return _internal_reason(); } template -inline PROTOBUF_ALWAYS_INLINE void WakeUpRequest::set_reason(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void WakeUpRequest::set_reason(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.reason_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:WakeUpRequest.reason) } -inline std::string* WakeUpRequest::mutable_reason() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_reason(); +inline ::std::string* PROTOBUF_NONNULL WakeUpRequest::mutable_reason() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_reason(); // @@protoc_insertion_point(field_mutable:WakeUpRequest.reason) return _s; } -inline const std::string& WakeUpRequest::_internal_reason() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& WakeUpRequest::_internal_reason() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.reason_.Get(); } -inline void WakeUpRequest::_internal_set_reason(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void WakeUpRequest::_internal_set_reason(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.reason_.Set(value, GetArena()); } -inline std::string* WakeUpRequest::_internal_mutable_reason() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL WakeUpRequest::_internal_mutable_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.reason_.Mutable( GetArena()); } -inline std::string* WakeUpRequest::release_reason() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE WakeUpRequest::release_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:WakeUpRequest.reason) - return _impl_.reason_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.reason_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.reason_.Set("", GetArena()); + } + return released; } -inline void WakeUpRequest::set_allocated_reason(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void WakeUpRequest::set_allocated_reason(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.reason_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.reason_.IsDefault()) { - _impl_.reason_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.reason_.IsDefault()) { + _impl_.reason_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:WakeUpRequest.reason) } @@ -306,4 +319,4 @@ inline void WakeUpRequest::set_allocated_reason(std::string* value) { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_WakeUpRpc_2eproto_2epb_2eh +#endif // WakeUpRpc_2eproto_2epb_2eh diff --git a/packages/streamr-proto-rpc/test/unit/RpcCommunicatorTest.cpp b/packages/streamr-proto-rpc/test/unit/RpcCommunicatorTest.cpp index 840dd462..7425a125 100644 --- a/packages/streamr-proto-rpc/test/unit/RpcCommunicatorTest.cpp +++ b/packages/streamr-proto-rpc/test/unit/RpcCommunicatorTest.cpp @@ -142,10 +142,10 @@ auto sendHelloRequest( HelloRequest request; request.set_myname("Test"); return folly::coro::blockingWait( - sender - .request( - "testFunction", request, ProtoCallContext()) - .scheduleOn(executor)); + folly::coro::co_withExecutor( + executor, + sender.request( + "testFunction", request, ProtoCallContext()))); } auto sendHelloNotification( @@ -153,8 +153,10 @@ auto sendHelloNotification( HelloRequest request; request.set_myname("Test"); folly::coro::blockingWait( - sender.notify("testFunction", request, ProtoCallContext()) - .scheduleOn(executor)); + folly::coro::co_withExecutor( + executor, + sender.notify( + "testFunction", request, ProtoCallContext()))); } void verifyClientError( @@ -308,10 +310,10 @@ TEST_F(RpcCommunicatorTest, TestCannotify) { "testFunction", [&requestMsg]( const HelloRequest& request, const ProtoCallContext& /* context */) - -> void { requestMsg = request.DebugString(); }); + -> void { requestMsg = request.myname(); }); setCallbacks(false); sendHelloNotification(communicator2, &executor); - EXPECT_EQ(requestMsg, "myName: \"Test\"\n"); + EXPECT_EQ(requestMsg, "Test"); } TEST_F(RpcCommunicatorTest, TestnotifyClientThrowsRuntimeError) { @@ -357,13 +359,14 @@ TEST_F(RpcCommunicatorTest, TestRpcTimeoutOnClientSide) { request.set_myname("Test"); try { - folly::coro::blockingWait(communicator2 - .request( - "testFunction", - request, - ProtoCallContext(), - 50ms) // NOLINT - .scheduleOn(&executor)); + folly::coro::blockingWait( + folly::coro::co_withExecutor( + &executor, + communicator2.request( + "testFunction", + request, + ProtoCallContext(), + 50ms))); // NOLINT // Test fails here EXPECT_TRUE(false); } catch (const RpcTimeout& ex) { @@ -402,14 +405,14 @@ TEST_F(RpcCommunicatorTest, TestRpcTimeoutOnServerSide) { HelloRequest request; request.set_myname("Test"); try { - auto result = - folly::coro::blockingWait(communicator2 - .request( - "testFunction", - request, - ProtoCallContext(), - 50ms) // NOLINT - .scheduleOn(&executor)); + auto result = folly::coro::blockingWait( + folly::coro::co_withExecutor( + &executor, + communicator2.request( + "testFunction", + request, + ProtoCallContext(), + 50ms))); // NOLINT EXPECT_EQ(true, false); } catch (const RpcTimeout& ex) { SLogger::info( @@ -428,7 +431,7 @@ TEST_F(RpcCommunicatorTest, TestRpcTimeoutOnClientSideForNotification) { "testFunction", [&requestMsg]( const HelloRequest& request, const ProtoCallContext& /* context */) - -> void { requestMsg = request.DebugString(); }); + -> void { requestMsg = request.myname(); }); HelloRequest request; request.set_myname("Test"); @@ -447,13 +450,14 @@ TEST_F(RpcCommunicatorTest, TestRpcTimeoutOnClientSideForNotification) { std::cout << "Calling notify() from thread id: " << std::this_thread::get_id() << "\n"; - folly::coro::blockingWait(communicator2 - .notify( - "testFunction", - request, - ProtoCallContext(), - 50ms) // NOLINT - .scheduleOn(&executor)); + folly::coro::blockingWait( + folly::coro::co_withExecutor( + &executor, + communicator2.notify( + "testFunction", + request, + ProtoCallContext(), + 50ms))); // NOLINT // Test fails here EXPECT_TRUE(false); } catch (const RpcTimeout& ex) { diff --git a/packages/streamr-trackerless-network/CMakeLists.txt b/packages/streamr-trackerless-network/CMakeLists.txt index 3a3db444..cea44dd3 100644 --- a/packages/streamr-trackerless-network/CMakeLists.txt +++ b/packages/streamr-trackerless-network/CMakeLists.txt @@ -60,7 +60,6 @@ target_link_libraries(streamr-trackerless-network INTERFACE streamr::streamr-utils INTERFACE Boost::algorithm PRIVATE protobuf::libprotobuf - PRIVATE protobuf::libprotoc INTERFACE Boost::uuid PRIVATE magic_enum::magic_enum PRIVATE Folly::folly diff --git a/packages/streamr-trackerless-network/proto.sh b/packages/streamr-trackerless-network/proto.sh index 2f33ce39..c7fad533 100755 --- a/packages/streamr-trackerless-network/proto.sh +++ b/packages/streamr-trackerless-network/proto.sh @@ -1,4 +1,6 @@ -PROTOC=../../build/vcpkg_installed/arm64-osx/tools/protobuf/protoc +# Use the protoc that matches the installed libprotobuf; triplet detected +# from the monorepo build dir (override with PROTOC=... if needed). +PROTOC=${PROTOC:-$(ls ../../build/vcpkg_installed/*/tools/protobuf/protoc 2>/dev/null | head -1)} PLUGIN=../streamr-proto-rpc/build/protobuf-streamr-plugin mkdir -p ./src/proto mkdir -p ./src/proto/packages/network/protos @@ -11,7 +13,7 @@ mkdir -p protos/packages/network/protos cp -r ../streamr-proto-rpc/protos/* protos/packages/proto-rpc/protos cp -r ../streamr-dht/protos/* protos/packages/dht/protos cp protos/NetworkRpc.proto protos/packages/network/protos -${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./src/proto/packages/network/protos --proto_path=./protos --cpp_out=./src/proto packages/network/protos/NetworkRpc.proto --experimental_allow_proto3_optional -${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./src/proto/packages/dht/protos --proto_path=./protos --cpp_out=./src/proto packages/dht/protos/DhtRpc.proto --experimental_allow_proto3_optional -${PROTOC} --proto_path=./protos --cpp_out=./src/proto packages/proto-rpc/protos/ProtoRpc.proto --experimental_allow_proto3_optional +${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./src/proto/packages/network/protos --proto_path=./protos --cpp_out=./src/proto packages/network/protos/NetworkRpc.proto +${PROTOC} --plugin=protoc-gen-streamr=${PLUGIN} --streamr_out=./src/proto/packages/dht/protos --proto_path=./protos --cpp_out=./src/proto packages/dht/protos/DhtRpc.proto +${PROTOC} --proto_path=./protos --cpp_out=./src/proto packages/proto-rpc/protos/ProtoRpc.proto rm -rf protos/packages diff --git a/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.cc b/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.cc index fd2d00b9..be005b54 100644 --- a/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.cc +++ b/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/dht/protos/DhtRpc.proto +// Protobuf C++ Version: 6.33.4 #include "packages/dht/protos/DhtRpc.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" @@ -18,9 +23,16 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; namespace dht { - template -PROTOBUF_CONSTEXPR WebsocketConnectionRequest::WebsocketConnectionRequest(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR WebsocketConnectionRequest::WebsocketConnectionRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(WebsocketConnectionRequest_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct WebsocketConnectionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR WebsocketConnectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~WebsocketConnectionRequestDefaultTypeInternal() {} @@ -31,8 +43,14 @@ struct WebsocketConnectionRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebsocketConnectionRequestDefaultTypeInternal _WebsocketConnectionRequest_default_instance_; - template -PROTOBUF_CONSTEXPR WebrtcConnectionRequest::WebrtcConnectionRequest(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR WebrtcConnectionRequest::WebrtcConnectionRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(WebrtcConnectionRequest_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct WebrtcConnectionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR WebrtcConnectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~WebrtcConnectionRequestDefaultTypeInternal() {} @@ -46,14 +64,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr UnlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : lockid_( + : _cached_size_{0}, + lockid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR UnlockRequest::UnlockRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(UnlockRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct UnlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR UnlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~UnlockRequestDefaultTypeInternal() {} @@ -64,8 +88,14 @@ struct UnlockRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnlockRequestDefaultTypeInternal _UnlockRequest_default_instance_; - template -PROTOBUF_CONSTEXPR StoreDataResponse::StoreDataResponse(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR StoreDataResponse::StoreDataResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(StoreDataResponse_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct StoreDataResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR StoreDataResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StoreDataResponseDefaultTypeInternal() {} @@ -79,17 +109,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RtcOffer::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : description_( + : _cached_size_{0}, + description_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), connectionid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR RtcOffer::RtcOffer(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RtcOffer_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RtcOfferDefaultTypeInternal { PROTOBUF_CONSTEXPR RtcOfferDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RtcOfferDefaultTypeInternal() {} @@ -103,17 +139,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RtcAnswer::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : description_( + : _cached_size_{0}, + description_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), connectionid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR RtcAnswer::RtcAnswer(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RtcAnswer_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RtcAnswerDefaultTypeInternal { PROTOBUF_CONSTEXPR RtcAnswerDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RtcAnswerDefaultTypeInternal() {} @@ -135,7 +177,13 @@ inline constexpr RouteMessageAck::Impl_::Impl_( template PROTOBUF_CONSTEXPR RouteMessageAck::RouteMessageAck(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RouteMessageAck_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RouteMessageAckDefaultTypeInternal { PROTOBUF_CONSTEXPR RouteMessageAckDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RouteMessageAckDefaultTypeInternal() {} @@ -149,15 +197,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RecursiveOperationRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : sessionid_( + : _cached_size_{0}, + sessionid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - operation_{static_cast< ::dht::RecursiveOperation >(0)}, - _cached_size_{0} {} + operation_{static_cast< ::dht::RecursiveOperation >(0)} {} template PROTOBUF_CONSTEXPR RecursiveOperationRequest::RecursiveOperationRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RecursiveOperationRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RecursiveOperationRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR RecursiveOperationRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RecursiveOperationRequestDefaultTypeInternal() {} @@ -171,14 +225,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr PingResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : requestid_( + : _cached_size_{0}, + requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR PingResponse::PingResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PingResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PingResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR PingResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PingResponseDefaultTypeInternal() {} @@ -192,14 +252,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr PingRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : requestid_( + : _cached_size_{0}, + requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR PingRequest::PingRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PingRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PingRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PingRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PingRequestDefaultTypeInternal() {} @@ -213,12 +279,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr LockResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : accepted_{false}, - _cached_size_{0} {} + : _cached_size_{0}, + accepted_{false} {} template PROTOBUF_CONSTEXPR LockResponse::LockResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(LockResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct LockResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR LockResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LockResponseDefaultTypeInternal() {} @@ -232,14 +304,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr LockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : lockid_( + : _cached_size_{0}, + lockid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR LockRequest::LockRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(LockRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct LockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR LockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LockRequestDefaultTypeInternal() {} @@ -250,8 +328,14 @@ struct LockRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LockRequestDefaultTypeInternal _LockRequest_default_instance_; - template -PROTOBUF_CONSTEXPR LeaveNotice::LeaveNotice(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR LeaveNotice::LeaveNotice(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(LeaveNotice_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct LeaveNoticeDefaultTypeInternal { PROTOBUF_CONSTEXPR LeaveNoticeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LeaveNoticeDefaultTypeInternal() {} @@ -265,7 +349,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr IceCandidate::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : candidate_( + : _cached_size_{0}, + candidate_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), mid_( @@ -273,12 +358,17 @@ inline constexpr IceCandidate::Impl_::Impl_( ::_pbi::ConstantInitialized()), connectionid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR IceCandidate::IceCandidate(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(IceCandidate_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct IceCandidateDefaultTypeInternal { PROTOBUF_CONSTEXPR IceCandidateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~IceCandidateDefaultTypeInternal() {} @@ -292,14 +382,20 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ExternalFetchDataRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : key_( + : _cached_size_{0}, + key_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ExternalFetchDataRequest::ExternalFetchDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalFetchDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalFetchDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalFetchDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalFetchDataRequestDefaultTypeInternal() {} @@ -313,12 +409,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr DisconnectNotice::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : disconnectmode_{static_cast< ::dht::DisconnectMode >(0)}, - _cached_size_{0} {} + : _cached_size_{0}, + disconnectmode_{static_cast< ::dht::DisconnectMode >(0)} {} template PROTOBUF_CONSTEXPR DisconnectNotice::DisconnectNotice(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(DisconnectNotice_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct DisconnectNoticeDefaultTypeInternal { PROTOBUF_CONSTEXPR DisconnectNoticeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~DisconnectNoticeDefaultTypeInternal() {} @@ -342,7 +444,13 @@ inline constexpr ConnectivityRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ConnectivityRequest::ConnectivityRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityRequestDefaultTypeInternal() {} @@ -356,16 +464,22 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ConnectivityMethod::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : host_( + : _cached_size_{0}, + host_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), port_{0u}, - tls_{false}, - _cached_size_{0} {} + tls_{false} {} template PROTOBUF_CONSTEXPR ConnectivityMethod::ConnectivityMethod(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityMethod_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityMethodDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityMethodDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityMethodDefaultTypeInternal() {} @@ -379,17 +493,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestRingPeersRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : ringid_( + : _cached_size_{0}, + ringid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestRingPeersRequest::ClosestRingPeersRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestRingPeersRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestRingPeersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestRingPeersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestRingPeersRequestDefaultTypeInternal() {} @@ -403,17 +523,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestPeersRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : nodeid_( + : _cached_size_{0}, + nodeid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestPeersRequest::ClosestPeersRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestPeersRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestPeersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestPeersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestPeersRequestDefaultTypeInternal() {} @@ -440,7 +566,13 @@ inline constexpr StoreDataRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR StoreDataRequest::StoreDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(StoreDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct StoreDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR StoreDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StoreDataRequestDefaultTypeInternal() {} @@ -473,7 +605,13 @@ inline constexpr PeerDescriptor::Impl_::Impl_( template PROTOBUF_CONSTEXPR PeerDescriptor::PeerDescriptor(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(PeerDescriptor_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct PeerDescriptorDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerDescriptorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerDescriptorDefaultTypeInternal() {} @@ -495,7 +633,13 @@ inline constexpr ExternalStoreDataRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ExternalStoreDataRequest::ExternalStoreDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalStoreDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalStoreDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalStoreDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalStoreDataRequestDefaultTypeInternal() {} @@ -525,7 +669,13 @@ inline constexpr DataEntry::Impl_::Impl_( template PROTOBUF_CONSTEXPR DataEntry::DataEntry(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(DataEntry_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct DataEntryDefaultTypeInternal { PROTOBUF_CONSTEXPR DataEntryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~DataEntryDefaultTypeInternal() {} @@ -556,7 +706,13 @@ inline constexpr ConnectivityResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR ConnectivityResponse::ConnectivityResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ConnectivityResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ConnectivityResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ConnectivityResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ConnectivityResponseDefaultTypeInternal() {} @@ -575,7 +731,13 @@ inline constexpr ReplicateDataRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR ReplicateDataRequest::ReplicateDataRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ReplicateDataRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ReplicateDataRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ReplicateDataRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ReplicateDataRequestDefaultTypeInternal() {} @@ -589,15 +751,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RecursiveOperationResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : closestconnectednodes_{}, + : _cached_size_{0}, + closestconnectednodes_{}, dataentries_{}, routingpath_{}, - noclosernodesfound_{false}, - _cached_size_{0} {} + noclosernodesfound_{false} {} template PROTOBUF_CONSTEXPR RecursiveOperationResponse::RecursiveOperationResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RecursiveOperationResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RecursiveOperationResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR RecursiveOperationResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RecursiveOperationResponseDefaultTypeInternal() {} @@ -620,7 +788,13 @@ inline constexpr HandshakeResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR HandshakeResponse::HandshakeResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HandshakeResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HandshakeResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR HandshakeResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HandshakeResponseDefaultTypeInternal() {} @@ -643,7 +817,13 @@ inline constexpr HandshakeRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR HandshakeRequest::HandshakeRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(HandshakeRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct HandshakeRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR HandshakeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HandshakeRequestDefaultTypeInternal() {} @@ -657,12 +837,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ExternalStoreDataResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : storers_{}, - _cached_size_{0} {} + : _cached_size_{0}, + storers_{} {} template PROTOBUF_CONSTEXPR ExternalStoreDataResponse::ExternalStoreDataResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalStoreDataResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalStoreDataResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalStoreDataResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalStoreDataResponseDefaultTypeInternal() {} @@ -676,12 +862,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ExternalFetchDataResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : entries_{}, - _cached_size_{0} {} + : _cached_size_{0}, + entries_{} {} template PROTOBUF_CONSTEXPR ExternalFetchDataResponse::ExternalFetchDataResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ExternalFetchDataResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ExternalFetchDataResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ExternalFetchDataResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExternalFetchDataResponseDefaultTypeInternal() {} @@ -695,16 +887,22 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestRingPeersResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : leftpeers_{}, + : _cached_size_{0}, + leftpeers_{}, rightpeers_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestRingPeersResponse::ClosestRingPeersResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestRingPeersResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestRingPeersResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestRingPeersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestRingPeersResponseDefaultTypeInternal() {} @@ -718,15 +916,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ClosestPeersResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : peers_{}, + : _cached_size_{0}, + peers_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR ClosestPeersResponse::ClosestPeersResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ClosestPeersResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ClosestPeersResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ClosestPeersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClosestPeersResponseDefaultTypeInternal() {} @@ -754,7 +958,13 @@ inline constexpr Message::Impl_::Impl_( template PROTOBUF_CONSTEXPR Message::Message(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(Message_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct MessageDefaultTypeInternal { PROTOBUF_CONSTEXPR MessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MessageDefaultTypeInternal() {} @@ -783,7 +993,13 @@ inline constexpr RouteMessageWrapper::Impl_::Impl_( template PROTOBUF_CONSTEXPR RouteMessageWrapper::RouteMessageWrapper(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RouteMessageWrapper_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RouteMessageWrapperDefaultTypeInternal { PROTOBUF_CONSTEXPR RouteMessageWrapperDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RouteMessageWrapperDefaultTypeInternal() {} @@ -795,491 +1011,343 @@ struct RouteMessageWrapperDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RouteMessageWrapperDefaultTypeInternal _RouteMessageWrapper_default_instance_; } // namespace dht -static ::_pb::Metadata file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[35]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[6]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[6]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto = nullptr; -const ::uint32_t TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _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(::dht::StoreDataRequest, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.data_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.creator_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.createdat_), - PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.ttl_), - ~0u, - 0, - ~0u, - 1, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::StoreDataResponse, _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(::dht::ExternalStoreDataRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _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(::dht::ExternalStoreDataRequest, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_.data_), - ~0u, - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataResponse, _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(::dht::ExternalStoreDataResponse, _impl_.storers_), - PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _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(::dht::ReplicateDataRequest, _impl_.entry_), - 0, - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _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(::dht::DataEntry, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.data_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.creator_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.createdat_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.storedat_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.ttl_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.stale_), - PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.deleted_), - ~0u, - 0, - ~0u, - 1, - 2, - ~0u, - ~0u, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _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(::dht::ClosestPeersRequest, _impl_.nodeid_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _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(::dht::ClosestPeersResponse, _impl_.peers_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _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(::dht::ClosestRingPeersRequest, _impl_.ringid_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _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(::dht::ClosestRingPeersResponse, _impl_.leftpeers_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.rightpeers_), - PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _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(::dht::RecursiveOperationRequest, _impl_.sessionid_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_.operation_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _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(::dht::RecursiveOperationResponse, _impl_.closestconnectednodes_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.dataentries_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.noclosernodesfound_), - PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.routingpath_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::PingRequest, _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(::dht::PingRequest, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::PingResponse, _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(::dht::PingResponse, _impl_.requestid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::LeaveNotice, _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(::dht::PeerDescriptor, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _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(::dht::PeerDescriptor, _impl_.nodeid_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.type_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.udp_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.tcp_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.websocket_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.region_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.ipaddress_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.publickey_), - PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.signature_), - ~0u, - ~0u, - 2, - 3, - 4, - 5, - 6, - 0, - 1, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _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(::dht::ConnectivityMethod, _impl_.port_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.host_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.tls_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _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(::dht::RouteMessageWrapper, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.sourcepeer_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.target_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.reachablethrough_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.routingpath_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.parallelrootnodeids_), - ~0u, - 0, - ~0u, - 1, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _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(::dht::RouteMessageAck, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_.error_), - ~0u, - 0, - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _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(::dht::ConnectivityRequest, _impl_.port_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.tls_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.host_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.allowselfsignedcertificate_), - ~0u, - ~0u, - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _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(::dht::ConnectivityResponse, _impl_.host_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.nattype_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.websocket_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.ipaddress_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.version_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.latitude_), - PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.longitude_), - ~0u, - ~0u, - 0, - ~0u, - ~0u, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _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(::dht::HandshakeRequest, _impl_.sourcepeerdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.targetpeerdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.version_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _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(::dht::HandshakeResponse, _impl_.sourcepeerdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.error_), - PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.version_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _split_ - ~0u, // no sizeof(Split) - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.messageid_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.sourcedescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.targetdescriptor_), - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.serviceid_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), - ~0u, - 0, - 1, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::WebsocketConnectionRequest, _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(::dht::WebrtcConnectionRequest, _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(::dht::RtcOffer, _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(::dht::RtcOffer, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_.connectionid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _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(::dht::RtcAnswer, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_.connectionid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _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(::dht::IceCandidate, _impl_.candidate_), - PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.mid_), - PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.connectionid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::LockRequest, _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(::dht::LockRequest, _impl_.lockid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::UnlockRequest, _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(::dht::UnlockRequest, _impl_.lockid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::LockResponse, _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(::dht::LockResponse, _impl_.accepted_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::DisconnectNotice, _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(::dht::DisconnectNotice, _impl_.disconnectmode_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataRequest, _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(::dht::ExternalFetchDataRequest, _impl_.key_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataResponse, _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(::dht::ExternalFetchDataResponse, _impl_.entries_), +const ::uint32_t + TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_._has_bits_), + 8, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.data_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.creator_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.createdat_), + PROTOBUF_FIELD_OFFSET(::dht::StoreDataRequest, _impl_.ttl_), + 0, + 2, + 1, + 3, + 4, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataRequest, _impl_.data_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalStoreDataResponse, _impl_.storers_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ReplicateDataRequest, _impl_.entry_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_._has_bits_), + 11, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.data_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.creator_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.createdat_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.storedat_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.ttl_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.stale_), + PROTOBUF_FIELD_OFFSET(::dht::DataEntry, _impl_.deleted_), + 0, + 2, + 1, + 3, + 4, + 5, + 6, + 7, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_.nodeid_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersRequest, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_.peers_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestPeersResponse, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_.ringid_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersRequest, _impl_.requestid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.leftpeers_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.rightpeers_), + PROTOBUF_FIELD_OFFSET(::dht::ClosestRingPeersResponse, _impl_.requestid_), + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_.sessionid_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationRequest, _impl_.operation_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.closestconnectednodes_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.dataentries_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.noclosernodesfound_), + PROTOBUF_FIELD_OFFSET(::dht::RecursiveOperationResponse, _impl_.routingpath_), + 0, + 1, + 3, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::PingRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::PingRequest, _impl_.requestid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::PingResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::PingResponse, _impl_.requestid_), + 0, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_._has_bits_), + 12, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.nodeid_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.udp_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.tcp_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.websocket_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.region_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.ipaddress_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.publickey_), + PROTOBUF_FIELD_OFFSET(::dht::PeerDescriptor, _impl_.signature_), + 0, + 6, + 3, + 4, + 5, + 7, + 8, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityMethod, _impl_.tls_), + 1, + 0, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.sourcepeer_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.target_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.reachablethrough_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.routingpath_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageWrapper, _impl_.parallelrootnodeids_), + 3, + 5, + 4, + 6, + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::dht::RouteMessageAck, _impl_.error_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.tls_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityRequest, _impl_.allowselfsignedcertificate_), + 1, + 2, + 0, + 3, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.nattype_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.websocket_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.ipaddress_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.version_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.latitude_), + PROTOBUF_FIELD_OFFSET(::dht::ConnectivityResponse, _impl_.longitude_), + 0, + 1, + 3, + 6, + 2, + 4, + 5, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.sourcepeerdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.targetpeerdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeRequest, _impl_.version_), + 1, + 2, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.sourcepeerdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.error_), + PROTOBUF_FIELD_OFFSET(::dht::HandshakeResponse, _impl_.version_), + 1, + 2, + 0, + 0x085, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_[0]), + 15, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.messageid_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.sourcedescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.targetdescriptor_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.serviceid_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_.body_), + 0, + 2, + 3, + 1, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 0x000, // bitmap + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::dht::RtcOffer, _impl_.connectionid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::dht::RtcAnswer, _impl_.connectionid_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.candidate_), + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.mid_), + PROTOBUF_FIELD_OFFSET(::dht::IceCandidate, _impl_.connectionid_), + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::LockRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::LockRequest, _impl_.lockid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::UnlockRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::UnlockRequest, _impl_.lockid_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::LockResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::LockResponse, _impl_.accepted_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::DisconnectNotice, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::DisconnectNotice, _impl_.disconnectmode_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataRequest, _impl_.key_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::dht::ExternalFetchDataResponse, _impl_.entries_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 13, -1, sizeof(::dht::StoreDataRequest)}, - {18, -1, -1, sizeof(::dht::StoreDataResponse)}, - {26, 36, -1, sizeof(::dht::ExternalStoreDataRequest)}, - {38, -1, -1, sizeof(::dht::ExternalStoreDataResponse)}, - {47, 56, -1, sizeof(::dht::ReplicateDataRequest)}, - {57, 73, -1, sizeof(::dht::DataEntry)}, - {81, -1, -1, sizeof(::dht::ClosestPeersRequest)}, - {91, -1, -1, sizeof(::dht::ClosestPeersResponse)}, - {101, -1, -1, sizeof(::dht::ClosestRingPeersRequest)}, - {111, -1, -1, sizeof(::dht::ClosestRingPeersResponse)}, - {122, -1, -1, sizeof(::dht::RecursiveOperationRequest)}, - {132, -1, -1, sizeof(::dht::RecursiveOperationResponse)}, - {144, -1, -1, sizeof(::dht::PingRequest)}, - {153, -1, -1, sizeof(::dht::PingResponse)}, - {162, -1, -1, sizeof(::dht::LeaveNotice)}, - {170, 187, -1, sizeof(::dht::PeerDescriptor)}, - {196, -1, -1, sizeof(::dht::ConnectivityMethod)}, - {207, 222, -1, sizeof(::dht::RouteMessageWrapper)}, - {229, 239, -1, sizeof(::dht::RouteMessageAck)}, - {241, 253, -1, sizeof(::dht::ConnectivityRequest)}, - {257, 272, -1, sizeof(::dht::ConnectivityResponse)}, - {279, 290, -1, sizeof(::dht::HandshakeRequest)}, - {293, 304, -1, sizeof(::dht::HandshakeResponse)}, - {307, 326, -1, sizeof(::dht::Message)}, - {336, -1, -1, sizeof(::dht::WebsocketConnectionRequest)}, - {344, -1, -1, sizeof(::dht::WebrtcConnectionRequest)}, - {352, -1, -1, sizeof(::dht::RtcOffer)}, - {362, -1, -1, sizeof(::dht::RtcAnswer)}, - {372, -1, -1, sizeof(::dht::IceCandidate)}, - {383, -1, -1, sizeof(::dht::LockRequest)}, - {392, -1, -1, sizeof(::dht::UnlockRequest)}, - {401, -1, -1, sizeof(::dht::LockResponse)}, - {410, -1, -1, sizeof(::dht::DisconnectNotice)}, - {419, -1, -1, sizeof(::dht::ExternalFetchDataRequest)}, - {428, -1, -1, sizeof(::dht::ExternalFetchDataResponse)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::dht::StoreDataRequest)}, + {13, sizeof(::dht::StoreDataResponse)}, + {14, sizeof(::dht::ExternalStoreDataRequest)}, + {21, sizeof(::dht::ExternalStoreDataResponse)}, + {26, sizeof(::dht::ReplicateDataRequest)}, + {31, sizeof(::dht::DataEntry)}, + {50, sizeof(::dht::ClosestPeersRequest)}, + {57, sizeof(::dht::ClosestPeersResponse)}, + {64, sizeof(::dht::ClosestRingPeersRequest)}, + {71, sizeof(::dht::ClosestRingPeersResponse)}, + {80, sizeof(::dht::RecursiveOperationRequest)}, + {87, sizeof(::dht::RecursiveOperationResponse)}, + {98, sizeof(::dht::PingRequest)}, + {103, sizeof(::dht::PingResponse)}, + {108, sizeof(::dht::LeaveNotice)}, + {109, sizeof(::dht::PeerDescriptor)}, + {130, sizeof(::dht::ConnectivityMethod)}, + {139, sizeof(::dht::RouteMessageWrapper)}, + {156, sizeof(::dht::RouteMessageAck)}, + {163, sizeof(::dht::ConnectivityRequest)}, + {174, sizeof(::dht::ConnectivityResponse)}, + {191, sizeof(::dht::HandshakeRequest)}, + {200, sizeof(::dht::HandshakeResponse)}, + {209, sizeof(::dht::Message)}, + {234, sizeof(::dht::WebsocketConnectionRequest)}, + {235, sizeof(::dht::WebrtcConnectionRequest)}, + {236, sizeof(::dht::RtcOffer)}, + {243, sizeof(::dht::RtcAnswer)}, + {250, sizeof(::dht::IceCandidate)}, + {259, sizeof(::dht::LockRequest)}, + {264, sizeof(::dht::UnlockRequest)}, + {269, sizeof(::dht::LockResponse)}, + {274, sizeof(::dht::DisconnectNotice)}, + {279, sizeof(::dht::ExternalFetchDataRequest)}, + {284, sizeof(::dht::ExternalFetchDataResponse)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::dht::_StoreDataRequest_default_instance_._instance, &::dht::_StoreDataResponse_default_instance_._instance, &::dht::_ExternalStoreDataRequest_default_instance_._instance, @@ -1316,7 +1384,8 @@ static const ::_pb::Message* const file_default_instances[] = { &::dht::_ExternalFetchDataRequest_default_instance_._instance, &::dht::_ExternalFetchDataResponse_default_instance_._instance, }; -const char descriptor_table_protodef_packages_2fdht_2fprotos_2fDhtRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_packages_2fdht_2fprotos_2fDhtRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n packages/dht/protos/DhtRpc.proto\022\003dht\032" "\033google/protobuf/empty.proto\032\031google/pro" "tobuf/any.proto\032\037google/protobuf/timesta" @@ -1463,15 +1532,15 @@ const char descriptor_table_protodef_packages_2fdht_2fprotos_2fDhtRpc_2eproto[] "dht.ExternalStoreDataResponseB\002H\002b\006proto" "3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_deps[4] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_deps[4] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_google_2fprotobuf_2ftimestamp_2eproto, &::descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, }; static ::absl::once_flag descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto = { false, false, 5761, @@ -1484,159 +1553,120 @@ const ::_pbi::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_ schemas, file_default_instances, TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto::offsets, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto, file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto, file_level_service_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter() { - return &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_packages_2fdht_2fprotos_2fDhtRpc_2eproto(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); namespace dht { -const ::google::protobuf::EnumDescriptor* RecursiveOperation_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RecursiveOperation_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t RecursiveOperation_internal_data_[] = { 196608u, 0u, }; -bool RecursiveOperation_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* NodeType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL NodeType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[1]; } PROTOBUF_CONSTINIT const uint32_t NodeType_internal_data_[] = { 131072u, 0u, }; -bool NodeType_IsValid(int value) { - return 0 <= value && value <= 1; -} -const ::google::protobuf::EnumDescriptor* RpcResponseError_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcResponseError_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[2]; } PROTOBUF_CONSTINIT const uint32_t RpcResponseError_internal_data_[] = { 262144u, 0u, }; -bool RpcResponseError_IsValid(int value) { - return 0 <= value && value <= 3; -} -const ::google::protobuf::EnumDescriptor* RouteMessageError_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RouteMessageError_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[3]; } PROTOBUF_CONSTINIT const uint32_t RouteMessageError_internal_data_[] = { 196608u, 0u, }; -bool RouteMessageError_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* HandshakeError_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL HandshakeError_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[4]; } PROTOBUF_CONSTINIT const uint32_t HandshakeError_internal_data_[] = { 196608u, 0u, }; -bool HandshakeError_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* DisconnectMode_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DisconnectMode_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto); return file_level_enum_descriptors_packages_2fdht_2fprotos_2fDhtRpc_2eproto[5]; } PROTOBUF_CONSTINIT const uint32_t DisconnectMode_internal_data_[] = { 131072u, 0u, }; -bool DisconnectMode_IsValid(int value) { - return 0 <= value && value <= 1; -} // =================================================================== class StoreDataRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_._has_bits_); - static const ::google::protobuf::Any& data(const StoreDataRequest* msg); - static void set_has_data(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::google::protobuf::Timestamp& createdat(const StoreDataRequest* msg); - static void set_has_createdat(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_._has_bits_); }; -const ::google::protobuf::Any& StoreDataRequest::_Internal::data(const StoreDataRequest* msg) { - return *msg->_impl_.data_; -} -const ::google::protobuf::Timestamp& StoreDataRequest::_Internal::createdat(const StoreDataRequest* msg) { - return *msg->_impl_.createdat_; -} void StoreDataRequest::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } void StoreDataRequest::clear_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ != nullptr) _impl_.createdat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -StoreDataRequest::StoreDataRequest(::google::protobuf::Arena* arena) +StoreDataRequest::StoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.StoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::StoreDataRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, key_(arena, from.key_), creator_(arena, from.creator_) {} StoreDataRequest::StoreDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StoreDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.data_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.data_) + _impl_.data_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.data_) : nullptr; - _impl_.createdat_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.createdat_) + _impl_.createdat_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.createdat_) : nullptr; _impl_.ttl_ = from._impl_.ttl_; // @@protoc_insertion_point(copy_constructor:dht.StoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE StoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, key_(arena), creator_(arena) {} -inline void StoreDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void StoreDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, ttl_) - @@ -1645,29 +1675,135 @@ inline void StoreDataRequest::SharedCtor(::_pb::Arena* arena) { } StoreDataRequest::~StoreDataRequest() { // @@protoc_insertion_point(destructor:dht.StoreDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void StoreDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - _impl_.creator_.Destroy(); - delete _impl_.data_; - delete _impl_.createdat_; - _impl_.~Impl_(); +inline void StoreDataRequest::SharedDtor(MessageLite& self) { + StoreDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + this_._impl_.creator_.Destroy(); + delete this_._impl_.data_; + delete this_._impl_.createdat_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL StoreDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StoreDataRequest(arena); +} +constexpr auto StoreDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(StoreDataRequest), + alignof(StoreDataRequest)); +} +constexpr auto StoreDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StoreDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StoreDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StoreDataRequest::SharedDtor, + static_cast(&StoreDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_._cached_size_), + false, + }, + &StoreDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* StoreDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void StoreDataRequest::InternalSwap(StoreDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StoreDataRequest_class_data_ = + StoreDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StoreDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StoreDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StoreDataRequest_class_data_.tc_table); + return StoreDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 2, 0, 2> +StoreDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _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), + StoreDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::StoreDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.key_)}}, + // .google.protobuf.Any data = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.data_)}}, + // bytes creator = 3; + {::_pbi::TcParser::FastBS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.creator_)}}, + // .google.protobuf.Timestamp createdAt = 4; + {::_pbi::TcParser::FastMtS1, + {34, 3, 1, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.createdat_)}}, + // uint32 ttl = 5; + {::_pbi::TcParser::FastV32S1, + {40, 4, 0, + PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.ttl_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Any data = 2; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.data_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes creator = 3; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.creator_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Timestamp createdAt = 4; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.createdat_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 ttl = 5; + {PROTOBUF_FIELD_OFFSET(StoreDataRequest, _impl_.ttl_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()}, + }}, + {{ + }}, +}; +void StoreDataRequest::InternalSwap(StoreDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata StoreDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -1675,14 +1811,22 @@ class StoreDataResponse::_Internal { public: }; -StoreDataResponse::StoreDataResponse(::google::protobuf::Arena* arena) +StoreDataResponse::StoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, StoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.StoreDataResponse) } StoreDataResponse::StoreDataResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, StoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StoreDataResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -1691,310 +1835,643 @@ StoreDataResponse::StoreDataResponse( // @@protoc_insertion_point(copy_constructor:dht.StoreDataResponse) } +inline void* PROTOBUF_NONNULL StoreDataResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StoreDataResponse(arena); +} +constexpr auto StoreDataResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(StoreDataResponse), + alignof(StoreDataResponse)); +} +constexpr auto StoreDataResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StoreDataResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StoreDataResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StoreDataResponse::SharedDtor, + static_cast(&StoreDataResponse::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StoreDataResponse, _impl_._cached_size_), + false, + }, + &StoreDataResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StoreDataResponse_class_data_ = + StoreDataResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StoreDataResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StoreDataResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StoreDataResponse_class_data_.tc_table); + return StoreDataResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +StoreDataResponse::_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 + StoreDataResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::StoreDataResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata StoreDataResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[1]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalStoreDataRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._has_bits_); - static const ::google::protobuf::Any& data(const ExternalStoreDataRequest* msg); - static void set_has_data(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._has_bits_); }; -const ::google::protobuf::Any& ExternalStoreDataRequest::_Internal::data(const ExternalStoreDataRequest* msg) { - return *msg->_impl_.data_; -} void ExternalStoreDataRequest::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -ExternalStoreDataRequest::ExternalStoreDataRequest(::google::protobuf::Arena* arena) +ExternalStoreDataRequest::ExternalStoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalStoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalStoreDataRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, key_(arena, from.key_) {} ExternalStoreDataRequest::ExternalStoreDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalStoreDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.data_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.data_) + _impl_.data_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.data_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.ExternalStoreDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ExternalStoreDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, key_(arena) {} -inline void ExternalStoreDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void ExternalStoreDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.data_ = {}; } ExternalStoreDataRequest::~ExternalStoreDataRequest() { // @@protoc_insertion_point(destructor:dht.ExternalStoreDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalStoreDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - delete _impl_.data_; - _impl_.~Impl_(); +inline void ExternalStoreDataRequest::SharedDtor(MessageLite& self) { + ExternalStoreDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + delete this_._impl_.data_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalStoreDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalStoreDataRequest(arena); +} +constexpr auto ExternalStoreDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ExternalStoreDataRequest), + alignof(ExternalStoreDataRequest)); +} +constexpr auto ExternalStoreDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalStoreDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalStoreDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalStoreDataRequest::SharedDtor, + static_cast(&ExternalStoreDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._cached_size_), + false, + }, + &ExternalStoreDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ExternalStoreDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ExternalStoreDataRequest::InternalSwap(ExternalStoreDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalStoreDataRequest_class_data_ = + ExternalStoreDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalStoreDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalStoreDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalStoreDataRequest_class_data_.tc_table); + return ExternalStoreDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> +ExternalStoreDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_._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), + ExternalStoreDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalStoreDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .google.protobuf.Any data = 2; + {::_pbi::TcParser::FastMtS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.data_)}}, + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Any data = 2; + {PROTOBUF_FIELD_OFFSET(ExternalStoreDataRequest, _impl_.data_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + }}, + {{ + }}, +}; +void ExternalStoreDataRequest::InternalSwap(ExternalStoreDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalStoreDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalStoreDataResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_._has_bits_); }; -ExternalStoreDataResponse::ExternalStoreDataResponse(::google::protobuf::Arena* arena) +ExternalStoreDataResponse::ExternalStoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalStoreDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : storers_{visibility, arena, from.storers_}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalStoreDataResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + storers_{visibility, arena, from.storers_} {} ExternalStoreDataResponse::ExternalStoreDataResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalStoreDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalStoreDataResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ExternalStoreDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : storers_{visibility, arena}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalStoreDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + storers_{visibility, arena} {} -inline void ExternalStoreDataResponse::SharedCtor(::_pb::Arena* arena) { +inline void ExternalStoreDataResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExternalStoreDataResponse::~ExternalStoreDataResponse() { // @@protoc_insertion_point(destructor:dht.ExternalStoreDataResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalStoreDataResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void ExternalStoreDataResponse::SharedDtor(MessageLite& self) { + ExternalStoreDataResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalStoreDataResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalStoreDataResponse(arena); +} +constexpr auto ExternalStoreDataResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_.storers_) + + decltype(ExternalStoreDataResponse::_impl_.storers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(ExternalStoreDataResponse), alignof(ExternalStoreDataResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ExternalStoreDataResponse::PlacementNew_, + sizeof(ExternalStoreDataResponse), + alignof(ExternalStoreDataResponse)); + } } - -::_pbi::CachedSize* ExternalStoreDataResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ExternalStoreDataResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalStoreDataResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalStoreDataResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalStoreDataResponse::SharedDtor, + static_cast(&ExternalStoreDataResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_._cached_size_), + false, + }, + &ExternalStoreDataResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ExternalStoreDataResponse::InternalSwap(ExternalStoreDataResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalStoreDataResponse_class_data_ = + ExternalStoreDataResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalStoreDataResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalStoreDataResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalStoreDataResponse_class_data_.tc_table); + return ExternalStoreDataResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +ExternalStoreDataResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _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), + ExternalStoreDataResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalStoreDataResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.PeerDescriptor storers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_.storers_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor storers = 1; + {PROTOBUF_FIELD_OFFSET(ExternalStoreDataResponse, _impl_.storers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + }}, +}; +void ExternalStoreDataResponse::InternalSwap(ExternalStoreDataResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalStoreDataResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[3]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ReplicateDataRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_._has_bits_); - static const ::dht::DataEntry& entry(const ReplicateDataRequest* msg); - static void set_has_entry(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_._has_bits_); }; -const ::dht::DataEntry& ReplicateDataRequest::_Internal::entry(const ReplicateDataRequest* msg) { - return *msg->_impl_.entry_; -} -ReplicateDataRequest::ReplicateDataRequest(::google::protobuf::Arena* arena) +ReplicateDataRequest::ReplicateDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ReplicateDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ReplicateDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ReplicateDataRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} ReplicateDataRequest::ReplicateDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ReplicateDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ReplicateDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ReplicateDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.entry_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::DataEntry>(arena, *from._impl_.entry_) + _impl_.entry_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.entry_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.ReplicateDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ReplicateDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void ReplicateDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void ReplicateDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.entry_ = {}; } ReplicateDataRequest::~ReplicateDataRequest() { // @@protoc_insertion_point(destructor:dht.ReplicateDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ReplicateDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - delete _impl_.entry_; - _impl_.~Impl_(); +inline void ReplicateDataRequest::SharedDtor(MessageLite& self) { + ReplicateDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.entry_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ReplicateDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ReplicateDataRequest(arena); +} +constexpr auto ReplicateDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ReplicateDataRequest), + alignof(ReplicateDataRequest)); +} +constexpr auto ReplicateDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ReplicateDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ReplicateDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ReplicateDataRequest::SharedDtor, + static_cast(&ReplicateDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_._cached_size_), + false, + }, + &ReplicateDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ReplicateDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ReplicateDataRequest::InternalSwap(ReplicateDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ReplicateDataRequest_class_data_ = + ReplicateDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ReplicateDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ReplicateDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ReplicateDataRequest_class_data_.tc_table); + return ReplicateDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +ReplicateDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _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), + ReplicateDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ReplicateDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.DataEntry entry = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_.entry_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.DataEntry entry = 1; + {PROTOBUF_FIELD_OFFSET(ReplicateDataRequest, _impl_.entry_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::DataEntry>()}, + }}, + {{ + }}, +}; +void ReplicateDataRequest::InternalSwap(ReplicateDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ReplicateDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[4]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class DataEntry::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._has_bits_); - static const ::google::protobuf::Any& data(const DataEntry* msg); - static void set_has_data(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::google::protobuf::Timestamp& createdat(const DataEntry* msg); - static void set_has_createdat(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::google::protobuf::Timestamp& storedat(const DataEntry* msg); - static void set_has_storedat(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._has_bits_); }; -const ::google::protobuf::Any& DataEntry::_Internal::data(const DataEntry* msg) { - return *msg->_impl_.data_; -} -const ::google::protobuf::Timestamp& DataEntry::_Internal::createdat(const DataEntry* msg) { - return *msg->_impl_.createdat_; -} -const ::google::protobuf::Timestamp& DataEntry::_Internal::storedat(const DataEntry* msg) { - return *msg->_impl_.storedat_; -} void DataEntry::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } void DataEntry::clear_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ != nullptr) _impl_.createdat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } void DataEntry::clear_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.storedat_ != nullptr) _impl_.storedat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -DataEntry::DataEntry(::google::protobuf::Arena* arena) +DataEntry::DataEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DataEntry_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.DataEntry) } -inline PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::DataEntry& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, key_(arena, from.key_), creator_(arena, from.creator_) {} DataEntry::DataEntry( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DataEntry& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DataEntry_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE DataEntry* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.data_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.data_) + _impl_.data_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.data_) : nullptr; - _impl_.createdat_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.createdat_) + _impl_.createdat_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.createdat_) : nullptr; - _impl_.storedat_ = (cached_has_bits & 0x00000004u) - ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.storedat_) + _impl_.storedat_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.storedat_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, ttl_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, ttl_), offsetof(Impl_, deleted_) - offsetof(Impl_, ttl_) + @@ -2002,16 +2479,16 @@ DataEntry::DataEntry( // @@protoc_insertion_point(copy_constructor:dht.DataEntry) } -inline PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE DataEntry::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, key_(arena), creator_(arena) {} -inline void DataEntry::SharedCtor(::_pb::Arena* arena) { +inline void DataEntry::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, deleted_) - @@ -2020,537 +2497,1512 @@ inline void DataEntry::SharedCtor(::_pb::Arena* arena) { } DataEntry::~DataEntry() { // @@protoc_insertion_point(destructor:dht.DataEntry) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void DataEntry::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - _impl_.creator_.Destroy(); - delete _impl_.data_; - delete _impl_.createdat_; - delete _impl_.storedat_; - _impl_.~Impl_(); +inline void DataEntry::SharedDtor(MessageLite& self) { + DataEntry& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + this_._impl_.creator_.Destroy(); + delete this_._impl_.data_; + delete this_._impl_.createdat_; + delete this_._impl_.storedat_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL DataEntry::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) DataEntry(arena); +} +constexpr auto DataEntry::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(DataEntry), + alignof(DataEntry)); +} +constexpr auto DataEntry::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_DataEntry_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DataEntry::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DataEntry::SharedDtor, + static_cast(&DataEntry::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._cached_size_), + false, + }, + &DataEntry::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* DataEntry::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void DataEntry::InternalSwap(DataEntry* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull DataEntry_class_data_ = + DataEntry::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +DataEntry::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&DataEntry_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(DataEntry_class_data_.tc_table); + return DataEntry_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 8, 3, 0, 2> +DataEntry::_table_ = { + { + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + DataEntry_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::DataEntry>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool deleted = 8; + {::_pbi::TcParser::FastV8S1, + {64, 7, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.deleted_)}}, + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.key_)}}, + // .google.protobuf.Any data = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.data_)}}, + // bytes creator = 3; + {::_pbi::TcParser::FastBS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.creator_)}}, + // .google.protobuf.Timestamp createdAt = 4; + {::_pbi::TcParser::FastMtS1, + {34, 3, 1, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.createdat_)}}, + // .google.protobuf.Timestamp storedAt = 5; + {::_pbi::TcParser::FastMtS1, + {42, 4, 2, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.storedat_)}}, + // uint32 ttl = 6; + {::_pbi::TcParser::FastV32S1, + {48, 5, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.ttl_)}}, + // bool stale = 7; + {::_pbi::TcParser::FastV8S1, + {56, 6, 0, + PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.stale_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Any data = 2; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.data_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes creator = 3; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.creator_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .google.protobuf.Timestamp createdAt = 4; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.createdat_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .google.protobuf.Timestamp storedAt = 5; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.storedat_), _Internal::kHasBitsOffset + 4, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 ttl = 6; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.ttl_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // bool stale = 7; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.stale_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // bool deleted = 8; + {PROTOBUF_FIELD_OFFSET(DataEntry, _impl_.deleted_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()}, + }}, + {{ + }}, +}; +void DataEntry::InternalSwap(DataEntry* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata DataEntry::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[5]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestPeersRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._has_bits_); }; -ClosestPeersRequest::ClosestPeersRequest(::google::protobuf::Arena* arena) +ClosestPeersRequest::ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : nodeid_(arena, from.nodeid_), - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestPeersRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + nodeid_(arena, from.nodeid_), + requestid_(arena, from.requestid_) {} ClosestPeersRequest::ClosestPeersRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestPeersRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : nodeid_(arena), - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + nodeid_(arena), + requestid_(arena) {} -inline void ClosestPeersRequest::SharedCtor(::_pb::Arena* arena) { +inline void ClosestPeersRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestPeersRequest::~ClosestPeersRequest() { // @@protoc_insertion_point(destructor:dht.ClosestPeersRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestPeersRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.nodeid_.Destroy(); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestPeersRequest::SharedDtor(MessageLite& self) { + ClosestPeersRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.nodeid_.Destroy(); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestPeersRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestPeersRequest(arena); +} +constexpr auto ClosestPeersRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClosestPeersRequest), + alignof(ClosestPeersRequest)); +} +constexpr auto ClosestPeersRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestPeersRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestPeersRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestPeersRequest::SharedDtor, + static_cast(&ClosestPeersRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._cached_size_), + false, + }, + &ClosestPeersRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ClosestPeersRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ClosestPeersRequest::InternalSwap(ClosestPeersRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_ = + ClosestPeersRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestPeersRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestPeersRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestPeersRequest_class_data_.tc_table); + return ClosestPeersRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 41, 2> +ClosestPeersRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_._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 + ClosestPeersRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestPeersRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.requestid_)}}, + // bytes nodeId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.nodeid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes nodeId = 1; + {PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.nodeid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestPeersRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\27\0\11\0\0\0\0\0" + "dht.ClosestPeersRequest" + "requestId" + }}, +}; +void ClosestPeersRequest::InternalSwap(ClosestPeersRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestPeersRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[6]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestPeersResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._has_bits_); }; -ClosestPeersResponse::ClosestPeersResponse(::google::protobuf::Arena* arena) +ClosestPeersResponse::ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : peers_{visibility, arena, from.peers_}, - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestPeersResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + peers_{visibility, arena, from.peers_}, + requestid_(arena, from.requestid_) {} ClosestPeersResponse::ClosestPeersResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestPeersResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : peers_{visibility, arena}, - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + peers_{visibility, arena}, + requestid_(arena) {} -inline void ClosestPeersResponse::SharedCtor(::_pb::Arena* arena) { +inline void ClosestPeersResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestPeersResponse::~ClosestPeersResponse() { // @@protoc_insertion_point(destructor:dht.ClosestPeersResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestPeersResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestPeersResponse::SharedDtor(MessageLite& self) { + ClosestPeersResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestPeersResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestPeersResponse(arena); +} +constexpr auto ClosestPeersResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_) + + decltype(ClosestPeersResponse::_impl_.peers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(ClosestPeersResponse), alignof(ClosestPeersResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ClosestPeersResponse::PlacementNew_, + sizeof(ClosestPeersResponse), + alignof(ClosestPeersResponse)); + } } - -::_pbi::CachedSize* ClosestPeersResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ClosestPeersResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestPeersResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestPeersResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestPeersResponse::SharedDtor, + static_cast(&ClosestPeersResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._cached_size_), + false, + }, + &ClosestPeersResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ClosestPeersResponse::InternalSwap(ClosestPeersResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_ = + ClosestPeersResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestPeersResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestPeersResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestPeersResponse_class_data_.tc_table); + return ClosestPeersResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 42, 2> +ClosestPeersResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_._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), + ClosestPeersResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestPeersResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.requestid_)}}, + // repeated .dht.PeerDescriptor peers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor peers = 1; + {PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.peers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestPeersResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\30\0\11\0\0\0\0\0" + "dht.ClosestPeersResponse" + "requestId" + }}, +}; +void ClosestPeersResponse::InternalSwap(ClosestPeersResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestPeersResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[7]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestRingPeersRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_._has_bits_); }; -ClosestRingPeersRequest::ClosestRingPeersRequest(::google::protobuf::Arena* arena) +ClosestRingPeersRequest::ClosestRingPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestRingPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : ringid_(arena, from.ringid_), - requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestRingPeersRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + ringid_(arena, from.ringid_), + requestid_(arena, from.requestid_) {} ClosestRingPeersRequest::ClosestRingPeersRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestRingPeersRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestRingPeersRequest) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : ringid_(arena), - requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ClosestRingPeersRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + ringid_(arena), + requestid_(arena) {} -inline void ClosestRingPeersRequest::SharedCtor(::_pb::Arena* arena) { +inline void ClosestRingPeersRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestRingPeersRequest::~ClosestRingPeersRequest() { // @@protoc_insertion_point(destructor:dht.ClosestRingPeersRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestRingPeersRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.ringid_.Destroy(); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestRingPeersRequest::SharedDtor(MessageLite& self) { + ClosestRingPeersRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.ringid_.Destroy(); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestRingPeersRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestRingPeersRequest(arena); +} +constexpr auto ClosestRingPeersRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClosestRingPeersRequest), + alignof(ClosestRingPeersRequest)); +} +constexpr auto ClosestRingPeersRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestRingPeersRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestRingPeersRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestRingPeersRequest::SharedDtor, + static_cast(&ClosestRingPeersRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_._cached_size_), + false, + }, + &ClosestRingPeersRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ClosestRingPeersRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ClosestRingPeersRequest::InternalSwap(ClosestRingPeersRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestRingPeersRequest_class_data_ = + ClosestRingPeersRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestRingPeersRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestRingPeersRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestRingPeersRequest_class_data_.tc_table); + return ClosestRingPeersRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 45, 2> +ClosestRingPeersRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_._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 + ClosestRingPeersRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestRingPeersRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.requestid_)}}, + // bytes ringId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.ringid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes ringId = 1; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.ringid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\33\0\11\0\0\0\0\0" + "dht.ClosestRingPeersRequest" + "requestId" + }}, +}; +void ClosestRingPeersRequest::InternalSwap(ClosestRingPeersRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestRingPeersRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[8]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClosestRingPeersResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_._has_bits_); }; -ClosestRingPeersResponse::ClosestRingPeersResponse(::google::protobuf::Arena* arena) +ClosestRingPeersResponse::ClosestRingPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ClosestRingPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : leftpeers_{visibility, arena, from.leftpeers_}, +PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ClosestRingPeersResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + leftpeers_{visibility, arena, from.leftpeers_}, rightpeers_{visibility, arena, from.rightpeers_}, - requestid_(arena, from.requestid_), - _cached_size_{0} {} + requestid_(arena, from.requestid_) {} ClosestRingPeersResponse::ClosestRingPeersResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClosestRingPeersResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ClosestRingPeersResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ClosestRingPeersResponse) } -inline PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : leftpeers_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE ClosestRingPeersResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + leftpeers_{visibility, arena}, rightpeers_{visibility, arena}, - requestid_(arena), - _cached_size_{0} {} + requestid_(arena) {} -inline void ClosestRingPeersResponse::SharedCtor(::_pb::Arena* arena) { +inline void ClosestRingPeersResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClosestRingPeersResponse::~ClosestRingPeersResponse() { // @@protoc_insertion_point(destructor:dht.ClosestRingPeersResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ClosestRingPeersResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void ClosestRingPeersResponse::SharedDtor(MessageLite& self) { + ClosestRingPeersResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClosestRingPeersResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClosestRingPeersResponse(arena); +} +constexpr auto ClosestRingPeersResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.leftpeers_) + + decltype(ClosestRingPeersResponse::_impl_.leftpeers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.rightpeers_) + + decltype(ClosestRingPeersResponse::_impl_.rightpeers_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(ClosestRingPeersResponse), alignof(ClosestRingPeersResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ClosestRingPeersResponse::PlacementNew_, + sizeof(ClosestRingPeersResponse), + alignof(ClosestRingPeersResponse)); + } } - -::_pbi::CachedSize* ClosestRingPeersResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ClosestRingPeersResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClosestRingPeersResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClosestRingPeersResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClosestRingPeersResponse::SharedDtor, + static_cast(&ClosestRingPeersResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_._cached_size_), + false, + }, + &ClosestRingPeersResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ClosestRingPeersResponse::InternalSwap(ClosestRingPeersResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClosestRingPeersResponse_class_data_ = + ClosestRingPeersResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClosestRingPeersResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClosestRingPeersResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClosestRingPeersResponse_class_data_.tc_table); + return ClosestRingPeersResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 46, 2> +ClosestRingPeersResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + ClosestRingPeersResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ClosestRingPeersResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // repeated .dht.PeerDescriptor leftPeers = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.leftpeers_)}}, + // repeated .dht.PeerDescriptor rightPeers = 2; + {::_pbi::TcParser::FastMtR1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.rightpeers_)}}, + // string requestId = 3; + {::_pbi::TcParser::FastUS1, + {26, 2, 0, + PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor leftPeers = 1; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.leftpeers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor rightPeers = 2; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.rightpeers_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 3; + {PROTOBUF_FIELD_OFFSET(ClosestRingPeersResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\34\0\0\11\0\0\0\0" + "dht.ClosestRingPeersResponse" + "requestId" + }}, +}; +void ClosestRingPeersResponse::InternalSwap(ClosestRingPeersResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ClosestRingPeersResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[9]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RecursiveOperationRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_._has_bits_); }; -RecursiveOperationRequest::RecursiveOperationRequest(::google::protobuf::Arena* arena) +RecursiveOperationRequest::RecursiveOperationRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RecursiveOperationRequest) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : sessionid_(arena, from.sessionid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RecursiveOperationRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + sessionid_(arena, from.sessionid_) {} RecursiveOperationRequest::RecursiveOperationRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RecursiveOperationRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.operation_ = from._impl_.operation_; // @@protoc_insertion_point(copy_constructor:dht.RecursiveOperationRequest) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : sessionid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RecursiveOperationRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + sessionid_(arena) {} -inline void RecursiveOperationRequest::SharedCtor(::_pb::Arena* arena) { +inline void RecursiveOperationRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.operation_ = {}; } RecursiveOperationRequest::~RecursiveOperationRequest() { // @@protoc_insertion_point(destructor:dht.RecursiveOperationRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RecursiveOperationRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.sessionid_.Destroy(); - _impl_.~Impl_(); +inline void RecursiveOperationRequest::SharedDtor(MessageLite& self) { + RecursiveOperationRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.sessionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RecursiveOperationRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RecursiveOperationRequest(arena); +} +constexpr auto RecursiveOperationRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RecursiveOperationRequest), + alignof(RecursiveOperationRequest)); +} +constexpr auto RecursiveOperationRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RecursiveOperationRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RecursiveOperationRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RecursiveOperationRequest::SharedDtor, + static_cast(&RecursiveOperationRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_._cached_size_), + false, + }, + &RecursiveOperationRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RecursiveOperationRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RecursiveOperationRequest::InternalSwap(RecursiveOperationRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RecursiveOperationRequest_class_data_ = + RecursiveOperationRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RecursiveOperationRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RecursiveOperationRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RecursiveOperationRequest_class_data_.tc_table); + return RecursiveOperationRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 47, 2> +RecursiveOperationRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_._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 + RecursiveOperationRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RecursiveOperationRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.RecursiveOperation operation = 2; + {::_pbi::TcParser::FastV32S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.operation_)}}, + // string sessionId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.sessionid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string sessionId = 1; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.sessionid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.RecursiveOperation operation = 2; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationRequest, _impl_.operation_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + "\35\11\0\0\0\0\0\0" + "dht.RecursiveOperationRequest" + "sessionId" + }}, +}; +void RecursiveOperationRequest::InternalSwap(RecursiveOperationRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RecursiveOperationRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[10]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RecursiveOperationResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_._has_bits_); }; -RecursiveOperationResponse::RecursiveOperationResponse(::google::protobuf::Arena* arena) +RecursiveOperationResponse::RecursiveOperationResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RecursiveOperationResponse) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : closestconnectednodes_{visibility, arena, from.closestconnectednodes_}, +PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RecursiveOperationResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + closestconnectednodes_{visibility, arena, from.closestconnectednodes_}, dataentries_{visibility, arena, from.dataentries_}, - routingpath_{visibility, arena, from.routingpath_}, - _cached_size_{0} {} + routingpath_{visibility, arena, from.routingpath_} {} RecursiveOperationResponse::RecursiveOperationResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RecursiveOperationResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RecursiveOperationResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.noclosernodesfound_ = from._impl_.noclosernodesfound_; // @@protoc_insertion_point(copy_constructor:dht.RecursiveOperationResponse) } -inline PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : closestconnectednodes_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE RecursiveOperationResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + closestconnectednodes_{visibility, arena}, dataentries_{visibility, arena}, - routingpath_{visibility, arena}, - _cached_size_{0} {} + routingpath_{visibility, arena} {} -inline void RecursiveOperationResponse::SharedCtor(::_pb::Arena* arena) { +inline void RecursiveOperationResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.noclosernodesfound_ = {}; } RecursiveOperationResponse::~RecursiveOperationResponse() { // @@protoc_insertion_point(destructor:dht.RecursiveOperationResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RecursiveOperationResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void RecursiveOperationResponse::SharedDtor(MessageLite& self) { + RecursiveOperationResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RecursiveOperationResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RecursiveOperationResponse(arena); +} +constexpr auto RecursiveOperationResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.closestconnectednodes_) + + decltype(RecursiveOperationResponse::_impl_.closestconnectednodes_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.dataentries_) + + decltype(RecursiveOperationResponse::_impl_.dataentries_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.routingpath_) + + decltype(RecursiveOperationResponse::_impl_.routingpath_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(RecursiveOperationResponse), alignof(RecursiveOperationResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RecursiveOperationResponse::PlacementNew_, + sizeof(RecursiveOperationResponse), + alignof(RecursiveOperationResponse)); + } } - -::_pbi::CachedSize* RecursiveOperationResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto RecursiveOperationResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RecursiveOperationResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RecursiveOperationResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RecursiveOperationResponse::SharedDtor, + static_cast(&RecursiveOperationResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_._cached_size_), + false, + }, + &RecursiveOperationResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void RecursiveOperationResponse::InternalSwap(RecursiveOperationResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RecursiveOperationResponse_class_data_ = + RecursiveOperationResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RecursiveOperationResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RecursiveOperationResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RecursiveOperationResponse_class_data_.tc_table); + return RecursiveOperationResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 3, 0, 2> +RecursiveOperationResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RecursiveOperationResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RecursiveOperationResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.PeerDescriptor routingPath = 4; + {::_pbi::TcParser::FastMtR1, + {34, 2, 2, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.routingpath_)}}, + // repeated .dht.PeerDescriptor closestConnectedNodes = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.closestconnectednodes_)}}, + // repeated .dht.DataEntry dataEntries = 2; + {::_pbi::TcParser::FastMtR1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.dataentries_)}}, + // bool noCloserNodesFound = 3; + {::_pbi::TcParser::FastV8S1, + {24, 3, 0, + PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.noclosernodesfound_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor closestConnectedNodes = 1; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.closestconnectednodes_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.DataEntry dataEntries = 2; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.dataentries_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool noCloserNodesFound = 3; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.noclosernodesfound_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // repeated .dht.PeerDescriptor routingPath = 4; + {PROTOBUF_FIELD_OFFSET(RecursiveOperationResponse, _impl_.routingpath_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::DataEntry>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + }}, +}; +void RecursiveOperationResponse::InternalSwap(RecursiveOperationResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RecursiveOperationResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[11]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PingRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PingRequest, _impl_._has_bits_); }; -PingRequest::PingRequest(::google::protobuf::Arena* arena) +PingRequest::PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.PingRequest) } -inline PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::PingRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + requestid_(arena, from.requestid_) {} PingRequest::PingRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PingRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.PingRequest) } -inline PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + requestid_(arena) {} -inline void PingRequest::SharedCtor(::_pb::Arena* arena) { +inline void PingRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PingRequest::~PingRequest() { // @@protoc_insertion_point(destructor:dht.PingRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PingRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void PingRequest::SharedDtor(MessageLite& self) { + PingRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PingRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PingRequest(arena); +} +constexpr auto PingRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PingRequest), + alignof(PingRequest)); +} +constexpr auto PingRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PingRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PingRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PingRequest::SharedDtor, + static_cast(&PingRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PingRequest, _impl_._cached_size_), + false, + }, + &PingRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PingRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PingRequest::InternalSwap(PingRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PingRequest_class_data_ = + PingRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PingRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PingRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PingRequest_class_data_.tc_table); + return PingRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 33, 2> +PingRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PingRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + PingRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::PingRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PingRequest, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(PingRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\17\11\0\0\0\0\0\0" + "dht.PingRequest" + "requestId" + }}, +}; +void PingRequest::InternalSwap(PingRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PingRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[12]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PingResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PingResponse, _impl_._has_bits_); }; -PingResponse::PingResponse(::google::protobuf::Arena* arena) +PingResponse::PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.PingResponse) } -inline PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : requestid_(arena, from.requestid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::PingResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + requestid_(arena, from.requestid_) {} PingResponse::PingResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PingResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PingResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.PingResponse) } -inline PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : requestid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE PingResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + requestid_(arena) {} -inline void PingResponse::SharedCtor(::_pb::Arena* arena) { +inline void PingResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PingResponse::~PingResponse() { // @@protoc_insertion_point(destructor:dht.PingResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PingResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void PingResponse::SharedDtor(MessageLite& self) { + PingResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PingResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PingResponse(arena); +} +constexpr auto PingResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PingResponse), + alignof(PingResponse)); +} +constexpr auto PingResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PingResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PingResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PingResponse::SharedDtor, + static_cast(&PingResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PingResponse, _impl_._cached_size_), + false, + }, + &PingResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PingResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PingResponse::InternalSwap(PingResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PingResponse_class_data_ = + PingResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PingResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PingResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PingResponse_class_data_.tc_table); + return PingResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 34, 2> +PingResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PingResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + PingResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::PingResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PingResponse, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(PingResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\20\11\0\0\0\0\0\0" + "dht.PingResponse" + "requestId" + }}, +}; +void PingResponse::InternalSwap(PingResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PingResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[13]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -2558,14 +4010,22 @@ class LeaveNotice::_Internal { public: }; -LeaveNotice::LeaveNotice(::google::protobuf::Arena* arena) +LeaveNotice::LeaveNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, LeaveNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.LeaveNotice) } LeaveNotice::LeaveNotice( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LeaveNotice& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, LeaveNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE LeaveNotice* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -2574,62 +4034,103 @@ LeaveNotice::LeaveNotice( // @@protoc_insertion_point(copy_constructor:dht.LeaveNotice) } +inline void* PROTOBUF_NONNULL LeaveNotice::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LeaveNotice(arena); +} +constexpr auto LeaveNotice::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(LeaveNotice), + alignof(LeaveNotice)); +} +constexpr auto LeaveNotice::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LeaveNotice_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LeaveNotice::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LeaveNotice::SharedDtor, + static_cast(&LeaveNotice::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LeaveNotice, _impl_._cached_size_), + false, + }, + &LeaveNotice::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LeaveNotice_class_data_ = + LeaveNotice::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LeaveNotice::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LeaveNotice_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LeaveNotice_class_data_.tc_table); + return LeaveNotice_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +LeaveNotice::_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 + LeaveNotice_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::LeaveNotice>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata LeaveNotice::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[14]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerDescriptor::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._has_bits_); - static const ::dht::ConnectivityMethod& udp(const PeerDescriptor* msg); - static void set_has_udp(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::dht::ConnectivityMethod& tcp(const PeerDescriptor* msg); - static void set_has_tcp(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::dht::ConnectivityMethod& websocket(const PeerDescriptor* msg); - static void set_has_websocket(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_region(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_ipaddress(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_publickey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_signature(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._has_bits_); }; -const ::dht::ConnectivityMethod& PeerDescriptor::_Internal::udp(const PeerDescriptor* msg) { - return *msg->_impl_.udp_; -} -const ::dht::ConnectivityMethod& PeerDescriptor::_Internal::tcp(const PeerDescriptor* msg) { - return *msg->_impl_.tcp_; -} -const ::dht::ConnectivityMethod& PeerDescriptor::_Internal::websocket(const PeerDescriptor* msg) { - return *msg->_impl_.websocket_; -} -PeerDescriptor::PeerDescriptor(::google::protobuf::Arena* arena) +PeerDescriptor::PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PeerDescriptor_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.PeerDescriptor) } -inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::PeerDescriptor& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, nodeid_(arena, from.nodeid_), @@ -2637,27 +4138,31 @@ inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( signature_(arena, from.signature_) {} PeerDescriptor::PeerDescriptor( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PeerDescriptor& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PeerDescriptor_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE PeerDescriptor* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.udp_ = (cached_has_bits & 0x00000004u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.udp_) + _impl_.udp_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.udp_) : nullptr; - _impl_.tcp_ = (cached_has_bits & 0x00000008u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.tcp_) + _impl_.tcp_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.tcp_) : nullptr; - _impl_.websocket_ = (cached_has_bits & 0x00000010u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.websocket_) + _impl_.websocket_ = (CheckHasBit(cached_has_bits, 0x00000020U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.websocket_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, type_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, type_), offsetof(Impl_, ipaddress_) - offsetof(Impl_, type_) + @@ -2665,17 +4170,17 @@ PeerDescriptor::PeerDescriptor( // @@protoc_insertion_point(copy_constructor:dht.PeerDescriptor) } -inline PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE PeerDescriptor::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, nodeid_(arena), publickey_(arena), signature_(arena) {} -inline void PeerDescriptor::SharedCtor(::_pb::Arena* arena) { +inline void PeerDescriptor::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, udp_), 0, offsetof(Impl_, ipaddress_) - @@ -2684,61 +4189,210 @@ inline void PeerDescriptor::SharedCtor(::_pb::Arena* arena) { } PeerDescriptor::~PeerDescriptor() { // @@protoc_insertion_point(destructor:dht.PeerDescriptor) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void PeerDescriptor::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.nodeid_.Destroy(); - _impl_.publickey_.Destroy(); - _impl_.signature_.Destroy(); - delete _impl_.udp_; - delete _impl_.tcp_; - delete _impl_.websocket_; - _impl_.~Impl_(); +inline void PeerDescriptor::SharedDtor(MessageLite& self) { + PeerDescriptor& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.nodeid_.Destroy(); + this_._impl_.publickey_.Destroy(); + this_._impl_.signature_.Destroy(); + delete this_._impl_.udp_; + delete this_._impl_.tcp_; + delete this_._impl_.websocket_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL PeerDescriptor::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) PeerDescriptor(arena); +} +constexpr auto PeerDescriptor::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PeerDescriptor), + alignof(PeerDescriptor)); +} +constexpr auto PeerDescriptor::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_PeerDescriptor_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PeerDescriptor::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PeerDescriptor::SharedDtor, + static_cast(&PeerDescriptor::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._cached_size_), + false, + }, + &PeerDescriptor::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* PeerDescriptor::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void PeerDescriptor::InternalSwap(PeerDescriptor* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_ = + PeerDescriptor::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +PeerDescriptor::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PeerDescriptor_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PeerDescriptor_class_data_.tc_table); + return PeerDescriptor_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 9, 3, 0, 2> +PeerDescriptor::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + PeerDescriptor_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::PeerDescriptor>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bytes nodeId = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.nodeid_)}}, + // .dht.NodeType type = 2; + {::_pbi::TcParser::FastV32S1, + {16, 6, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.type_)}}, + // .dht.ConnectivityMethod udp = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.udp_)}}, + // .dht.ConnectivityMethod tcp = 4; + {::_pbi::TcParser::FastMtS1, + {34, 4, 1, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.tcp_)}}, + // .dht.ConnectivityMethod websocket = 5; + {::_pbi::TcParser::FastMtS1, + {42, 5, 2, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.websocket_)}}, + // optional uint32 region = 6; + {::_pbi::TcParser::FastV32S1, + {48, 7, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.region_)}}, + // optional uint32 ipAddress = 7; + {::_pbi::TcParser::FastV32S1, + {56, 8, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.ipaddress_)}}, + // optional bytes publicKey = 8; + {::_pbi::TcParser::FastBS1, + {66, 1, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.publickey_)}}, + // optional bytes signature = 9; + {::_pbi::TcParser::FastBS1, + {74, 2, 0, + PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.signature_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes nodeId = 1; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.nodeid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .dht.NodeType type = 2; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.type_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .dht.ConnectivityMethod udp = 3; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.udp_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityMethod tcp = 4; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.tcp_), _Internal::kHasBitsOffset + 4, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityMethod websocket = 5; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.websocket_), _Internal::kHasBitsOffset + 5, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional uint32 region = 6; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.region_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 ipAddress = 7; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.ipaddress_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional bytes publicKey = 8; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.publickey_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // optional bytes signature = 9; + {PROTOBUF_FIELD_OFFSET(PeerDescriptor, _impl_.signature_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + }}, + {{ + }}, +}; +void PeerDescriptor::InternalSwap(PeerDescriptor* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata PeerDescriptor::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[15]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityMethod::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._has_bits_); }; -ConnectivityMethod::ConnectivityMethod(::google::protobuf::Arena* arena) +ConnectivityMethod::ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityMethod_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ConnectivityMethod) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : host_(arena, from.host_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ConnectivityMethod& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + host_(arena, from.host_) {} ConnectivityMethod::ConnectivityMethod( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityMethod& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityMethod_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityMethod* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); - ::memcpy(reinterpret_cast(&_impl_) + + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, port_), offsetof(Impl_, tls_) - offsetof(Impl_, port_) + @@ -2746,15 +4400,15 @@ ConnectivityMethod::ConnectivityMethod( // @@protoc_insertion_point(copy_constructor:dht.ConnectivityMethod) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : host_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ConnectivityMethod::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + host_(arena) {} -inline void ConnectivityMethod::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityMethod::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), 0, offsetof(Impl_, tls_) - @@ -2763,58 +4417,142 @@ inline void ConnectivityMethod::SharedCtor(::_pb::Arena* arena) { } ConnectivityMethod::~ConnectivityMethod() { // @@protoc_insertion_point(destructor:dht.ConnectivityMethod) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityMethod::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.host_.Destroy(); - _impl_.~Impl_(); +inline void ConnectivityMethod::SharedDtor(MessageLite& self) { + ConnectivityMethod& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.host_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityMethod::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityMethod(arena); +} +constexpr auto ConnectivityMethod::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityMethod), + alignof(ConnectivityMethod)); +} +constexpr auto ConnectivityMethod::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityMethod_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityMethod::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityMethod::SharedDtor, + static_cast(&ConnectivityMethod::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_._cached_size_), + false, + }, + &ConnectivityMethod::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityMethod::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityMethod::InternalSwap(ConnectivityMethod* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_ = + ConnectivityMethod::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityMethod::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityMethod_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityMethod_class_data_.tc_table); + return ConnectivityMethod_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 35, 2> +ConnectivityMethod::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ConnectivityMethod_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 port = 1; + {::_pbi::TcParser::FastV32S1, + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.port_)}}, + // string host = 2; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.host_)}}, + // bool tls = 3; + {::_pbi::TcParser::FastV8S1, + {24, 2, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.tls_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 1; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.port_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string host = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.host_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool tls = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityMethod, _impl_.tls_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\26\0\4\0\0\0\0\0" + "dht.ConnectivityMethod" + "host" + }}, +}; +void ConnectivityMethod::InternalSwap(ConnectivityMethod* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityMethod::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[16]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RouteMessageWrapper::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._has_bits_); - static const ::dht::PeerDescriptor& sourcepeer(const RouteMessageWrapper* msg); - static void set_has_sourcepeer(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::dht::Message& message(const RouteMessageWrapper* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& RouteMessageWrapper::_Internal::sourcepeer(const RouteMessageWrapper* msg) { - return *msg->_impl_.sourcepeer_; -} -const ::dht::Message& RouteMessageWrapper::_Internal::message(const RouteMessageWrapper* msg) { - return *msg->_impl_.message_; -} -RouteMessageWrapper::RouteMessageWrapper(::google::protobuf::Arena* arena) +RouteMessageWrapper::RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageWrapper_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RouteMessageWrapper) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RouteMessageWrapper& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, reachablethrough_{visibility, arena, from.reachablethrough_}, @@ -2824,27 +4562,31 @@ inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( target_(arena, from.target_) {} RouteMessageWrapper::RouteMessageWrapper( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageWrapper& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageWrapper_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RouteMessageWrapper* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeer_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcepeer_) + _impl_.sourcepeer_ = (CheckHasBit(cached_has_bits, 0x00000020U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeer_) : nullptr; - _impl_.message_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::dht::Message>(arena, *from._impl_.message_) + _impl_.message_ = (CheckHasBit(cached_has_bits, 0x00000040U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.message_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.RouteMessageWrapper) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, reachablethrough_{visibility, arena}, routingpath_{visibility, arena}, @@ -2852,9 +4594,9 @@ inline PROTOBUF_NDEBUG_INLINE RouteMessageWrapper::Impl_::Impl_( requestid_(arena), target_(arena) {} -inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* arena) { +inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeer_), 0, offsetof(Impl_, message_) - @@ -2863,136 +4605,377 @@ inline void RouteMessageWrapper::SharedCtor(::_pb::Arena* arena) { } RouteMessageWrapper::~RouteMessageWrapper() { // @@protoc_insertion_point(destructor:dht.RouteMessageWrapper) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RouteMessageWrapper::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.target_.Destroy(); - delete _impl_.sourcepeer_; - delete _impl_.message_; - _impl_.~Impl_(); +inline void RouteMessageWrapper::SharedDtor(MessageLite& self) { + RouteMessageWrapper& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.target_.Destroy(); + delete this_._impl_.sourcepeer_; + delete this_._impl_.message_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RouteMessageWrapper::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RouteMessageWrapper(arena); +} +constexpr auto RouteMessageWrapper::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.reachablethrough_) + + decltype(RouteMessageWrapper::_impl_.reachablethrough_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.routingpath_) + + decltype(RouteMessageWrapper::_impl_.routingpath_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.parallelrootnodeids_) + + decltype(RouteMessageWrapper::_impl_.parallelrootnodeids_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(RouteMessageWrapper), alignof(RouteMessageWrapper), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RouteMessageWrapper::PlacementNew_, + sizeof(RouteMessageWrapper), + alignof(RouteMessageWrapper)); + } } - -::_pbi::CachedSize* RouteMessageWrapper::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto RouteMessageWrapper::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RouteMessageWrapper_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RouteMessageWrapper::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RouteMessageWrapper::SharedDtor, + static_cast(&RouteMessageWrapper::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_._cached_size_), + false, + }, + &RouteMessageWrapper::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void RouteMessageWrapper::InternalSwap(RouteMessageWrapper* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_ = + RouteMessageWrapper::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RouteMessageWrapper::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RouteMessageWrapper_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RouteMessageWrapper_class_data_.tc_table); + return RouteMessageWrapper_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 4, 60, 2> +RouteMessageWrapper::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _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 + 4, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RouteMessageWrapper_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RouteMessageWrapper>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 3, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.requestid_)}}, + // .dht.PeerDescriptor sourcePeer = 2; + {::_pbi::TcParser::FastMtS1, + {18, 5, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.sourcepeer_)}}, + // bytes target = 3; + {::_pbi::TcParser::FastBS1, + {26, 4, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.target_)}}, + // .dht.Message message = 4; + {::_pbi::TcParser::FastMtS1, + {34, 6, 1, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.message_)}}, + // repeated .dht.PeerDescriptor reachableThrough = 5; + {::_pbi::TcParser::FastMtR1, + {42, 0, 2, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.reachablethrough_)}}, + // repeated .dht.PeerDescriptor routingPath = 6; + {::_pbi::TcParser::FastMtR1, + {50, 1, 3, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.routingpath_)}}, + // repeated string parallelRootNodeIds = 7; + {::_pbi::TcParser::FastUR1, + {58, 2, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.parallelrootnodeids_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.requestid_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.PeerDescriptor sourcePeer = 2; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.sourcepeer_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes target = 3; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.target_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .dht.Message message = 4; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.message_), _Internal::kHasBitsOffset + 6, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor reachableThrough = 5; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.reachablethrough_), _Internal::kHasBitsOffset + 0, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor routingPath = 6; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.routingpath_), _Internal::kHasBitsOffset + 1, 3, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated string parallelRootNodeIds = 7; + {PROTOBUF_FIELD_OFFSET(RouteMessageWrapper, _impl_.parallelrootnodeids_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::Message>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\27\11\0\0\0\0\0\23" + "dht.RouteMessageWrapper" + "requestId" + "parallelRootNodeIds" + }}, +}; +void RouteMessageWrapper::InternalSwap(RouteMessageWrapper* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RouteMessageWrapper::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[17]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RouteMessageAck::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._has_bits_); - static void set_has_error(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._has_bits_); }; -RouteMessageAck::RouteMessageAck(::google::protobuf::Arena* arena) +RouteMessageAck::RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageAck_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RouteMessageAck) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RouteMessageAck& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, requestid_(arena, from.requestid_) {} RouteMessageAck::RouteMessageAck( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageAck& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RouteMessageAck_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RouteMessageAck* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.error_ = from._impl_.error_; // @@protoc_insertion_point(copy_constructor:dht.RouteMessageAck) } -inline PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RouteMessageAck::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, requestid_(arena) {} -inline void RouteMessageAck::SharedCtor(::_pb::Arena* arena) { +inline void RouteMessageAck::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.error_ = {}; } RouteMessageAck::~RouteMessageAck() { // @@protoc_insertion_point(destructor:dht.RouteMessageAck) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RouteMessageAck::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.~Impl_(); +inline void RouteMessageAck::SharedDtor(MessageLite& self) { + RouteMessageAck& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RouteMessageAck::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RouteMessageAck(arena); +} +constexpr auto RouteMessageAck::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RouteMessageAck), + alignof(RouteMessageAck)); +} +constexpr auto RouteMessageAck::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RouteMessageAck_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RouteMessageAck::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RouteMessageAck::SharedDtor, + static_cast(&RouteMessageAck::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._cached_size_), + false, + }, + &RouteMessageAck::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RouteMessageAck::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RouteMessageAck::InternalSwap(RouteMessageAck* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_ = + RouteMessageAck::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RouteMessageAck::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RouteMessageAck_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RouteMessageAck_class_data_.tc_table); + return RouteMessageAck_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 37, 2> +RouteMessageAck::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_._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 + RouteMessageAck_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RouteMessageAck>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // optional .dht.RouteMessageError error = 2; + {::_pbi::TcParser::FastV32S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.error_)}}, + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.requestid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .dht.RouteMessageError error = 2; + {PROTOBUF_FIELD_OFFSET(RouteMessageAck, _impl_.error_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + "\23\11\0\0\0\0\0\0" + "dht.RouteMessageAck" + "requestId" + }}, +}; +void RouteMessageAck::InternalSwap(RouteMessageAck* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RouteMessageAck::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[18]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._has_bits_); - static void set_has_host(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._has_bits_); }; -ConnectivityRequest::ConnectivityRequest(::google::protobuf::Arena* arena) +ConnectivityRequest::ConnectivityRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ConnectivityRequest) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ConnectivityRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, host_(arena, from.host_) {} ConnectivityRequest::ConnectivityRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); - ::memcpy(reinterpret_cast(&_impl_) + + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, port_), offsetof(Impl_, allowselfsignedcertificate_) - offsetof(Impl_, port_) + @@ -3000,15 +4983,15 @@ ConnectivityRequest::ConnectivityRequest( // @@protoc_insertion_point(copy_constructor:dht.ConnectivityRequest) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ConnectivityRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, host_(arena) {} -inline void ConnectivityRequest::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, port_), 0, offsetof(Impl_, allowselfsignedcertificate_) - @@ -3017,57 +5000,147 @@ inline void ConnectivityRequest::SharedCtor(::_pb::Arena* arena) { } ConnectivityRequest::~ConnectivityRequest() { // @@protoc_insertion_point(destructor:dht.ConnectivityRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.host_.Destroy(); - _impl_.~Impl_(); +inline void ConnectivityRequest::SharedDtor(MessageLite& self) { + ConnectivityRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.host_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityRequest(arena); +} +constexpr auto ConnectivityRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityRequest), + alignof(ConnectivityRequest)); +} +constexpr auto ConnectivityRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityRequest::SharedDtor, + static_cast(&ConnectivityRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._cached_size_), + false, + }, + &ConnectivityRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityRequest::InternalSwap(ConnectivityRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityRequest_class_data_ = + ConnectivityRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityRequest_class_data_.tc_table); + return ConnectivityRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 36, 2> +ConnectivityRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_._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 + ConnectivityRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ConnectivityRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool allowSelfSignedCertificate = 4; + {::_pbi::TcParser::FastV8S1, + {32, 3, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.allowselfsignedcertificate_)}}, + // uint32 port = 1; + {::_pbi::TcParser::FastV32S1, + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.port_)}}, + // bool tls = 2; + {::_pbi::TcParser::FastV8S1, + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.tls_)}}, + // optional string host = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.host_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 1; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.port_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // bool tls = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.tls_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // optional string host = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.host_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool allowSelfSignedCertificate = 4; + {PROTOBUF_FIELD_OFFSET(ConnectivityRequest, _impl_.allowselfsignedcertificate_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\27\0\0\4\0\0\0\0" + "dht.ConnectivityRequest" + "host" + }}, +}; +void ConnectivityRequest::InternalSwap(ConnectivityRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[19]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ConnectivityResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_._has_bits_); - static const ::dht::ConnectivityMethod& websocket(const ConnectivityResponse* msg); - static void set_has_websocket(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_latitude(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_longitude(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_._has_bits_); }; -const ::dht::ConnectivityMethod& ConnectivityResponse::_Internal::websocket(const ConnectivityResponse* msg) { - return *msg->_impl_.websocket_; -} -ConnectivityResponse::ConnectivityResponse(::google::protobuf::Arena* arena) +ConnectivityResponse::ConnectivityResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ConnectivityResponse) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ConnectivityResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, host_(arena, from.host_), @@ -3075,21 +5148,25 @@ inline PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( version_(arena, from.version_) {} ConnectivityResponse::ConnectivityResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ConnectivityResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ConnectivityResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.websocket_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::ConnectivityMethod>(arena, *from._impl_.websocket_) + _impl_.websocket_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.websocket_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, latitude_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, latitude_), offsetof(Impl_, ipaddress_) - offsetof(Impl_, latitude_) + @@ -3097,17 +5174,17 @@ ConnectivityResponse::ConnectivityResponse( // @@protoc_insertion_point(copy_constructor:dht.ConnectivityResponse) } -inline PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ConnectivityResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, host_(arena), nattype_(arena), version_(arena) {} -inline void ConnectivityResponse::SharedCtor(::_pb::Arena* arena) { +inline void ConnectivityResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, websocket_), 0, offsetof(Impl_, ipaddress_) - @@ -3116,93 +5193,209 @@ inline void ConnectivityResponse::SharedCtor(::_pb::Arena* arena) { } ConnectivityResponse::~ConnectivityResponse() { // @@protoc_insertion_point(destructor:dht.ConnectivityResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ConnectivityResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.host_.Destroy(); - _impl_.nattype_.Destroy(); - _impl_.version_.Destroy(); - delete _impl_.websocket_; - _impl_.~Impl_(); +inline void ConnectivityResponse::SharedDtor(MessageLite& self) { + ConnectivityResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.host_.Destroy(); + this_._impl_.nattype_.Destroy(); + this_._impl_.version_.Destroy(); + delete this_._impl_.websocket_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ConnectivityResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ConnectivityResponse(arena); +} +constexpr auto ConnectivityResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ConnectivityResponse), + alignof(ConnectivityResponse)); +} +constexpr auto ConnectivityResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ConnectivityResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConnectivityResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConnectivityResponse::SharedDtor, + static_cast(&ConnectivityResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_._cached_size_), + false, + }, + &ConnectivityResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ConnectivityResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ConnectivityResponse::InternalSwap(ConnectivityResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ConnectivityResponse_class_data_ = + ConnectivityResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ConnectivityResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ConnectivityResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ConnectivityResponse_class_data_.tc_table); + return ConnectivityResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 1, 51, 2> +ConnectivityResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _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), + ConnectivityResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ConnectivityResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string host = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.host_)}}, + // string natType = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.nattype_)}}, + // .dht.ConnectivityMethod websocket = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.websocket_)}}, + // uint32 ipAddress = 4; + {::_pbi::TcParser::FastV32S1, + {32, 6, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.ipaddress_)}}, + // string version = 5; + {::_pbi::TcParser::FastUS1, + {42, 2, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.version_)}}, + // optional double latitude = 6; + {::_pbi::TcParser::FastF64S1, + {49, 4, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.latitude_)}}, + // optional double longitude = 7; + {::_pbi::TcParser::FastF64S1, + {57, 5, 0, + PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.longitude_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string host = 1; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.host_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string natType = 2; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.nattype_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.ConnectivityMethod websocket = 3; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.websocket_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 ipAddress = 4; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.ipaddress_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string version = 5; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.version_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional double latitude = 6; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.latitude_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // optional double longitude = 7; + {PROTOBUF_FIELD_OFFSET(ConnectivityResponse, _impl_.longitude_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::ConnectivityMethod>()}, + }}, + {{ + "\30\4\7\0\0\7\0\0" + "dht.ConnectivityResponse" + "host" + "natType" + "version" + }}, +}; +void ConnectivityResponse::InternalSwap(ConnectivityResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ConnectivityResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[20]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HandshakeRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_._has_bits_); - static const ::dht::PeerDescriptor& sourcepeerdescriptor(const HandshakeRequest* msg); - static void set_has_sourcepeerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::dht::PeerDescriptor& targetpeerdescriptor(const HandshakeRequest* msg); - static void set_has_targetpeerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& HandshakeRequest::_Internal::sourcepeerdescriptor(const HandshakeRequest* msg) { - return *msg->_impl_.sourcepeerdescriptor_; -} -const ::dht::PeerDescriptor& HandshakeRequest::_Internal::targetpeerdescriptor(const HandshakeRequest* msg) { - return *msg->_impl_.targetpeerdescriptor_; -} -HandshakeRequest::HandshakeRequest(::google::protobuf::Arena* arena) +HandshakeRequest::HandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.HandshakeRequest) } -inline PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::HandshakeRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, version_(arena, from.version_) {} HandshakeRequest::HandshakeRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HandshakeRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeerdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcepeerdescriptor_) + _impl_.sourcepeerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeerdescriptor_) : nullptr; - _impl_.targetpeerdescriptor_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.targetpeerdescriptor_) + _impl_.targetpeerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.targetpeerdescriptor_) : nullptr; // @@protoc_insertion_point(copy_constructor:dht.HandshakeRequest) } -inline PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE HandshakeRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, version_(arena) {} -inline void HandshakeRequest::SharedCtor(::_pb::Arena* arena) { +inline void HandshakeRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeerdescriptor_), 0, offsetof(Impl_, targetpeerdescriptor_) - @@ -3211,86 +5404,181 @@ inline void HandshakeRequest::SharedCtor(::_pb::Arena* arena) { } HandshakeRequest::~HandshakeRequest() { // @@protoc_insertion_point(destructor:dht.HandshakeRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void HandshakeRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.version_.Destroy(); - delete _impl_.sourcepeerdescriptor_; - delete _impl_.targetpeerdescriptor_; - _impl_.~Impl_(); +inline void HandshakeRequest::SharedDtor(MessageLite& self) { + HandshakeRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.version_.Destroy(); + delete this_._impl_.sourcepeerdescriptor_; + delete this_._impl_.targetpeerdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL HandshakeRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HandshakeRequest(arena); +} +constexpr auto HandshakeRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HandshakeRequest), + alignof(HandshakeRequest)); +} +constexpr auto HandshakeRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HandshakeRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HandshakeRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HandshakeRequest::SharedDtor, + static_cast(&HandshakeRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_._cached_size_), + false, + }, + &HandshakeRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* HandshakeRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void HandshakeRequest::InternalSwap(HandshakeRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HandshakeRequest_class_data_ = + HandshakeRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HandshakeRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HandshakeRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HandshakeRequest_class_data_.tc_table); + return HandshakeRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 36, 2> +HandshakeRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + HandshakeRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::HandshakeRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.sourcepeerdescriptor_)}}, + // optional .dht.PeerDescriptor targetPeerDescriptor = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 1, + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.targetpeerdescriptor_)}}, + // string version = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.version_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.sourcepeerdescriptor_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .dht.PeerDescriptor targetPeerDescriptor = 2; + {PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.targetpeerdescriptor_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string version = 3; + {PROTOBUF_FIELD_OFFSET(HandshakeRequest, _impl_.version_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\24\0\0\7\0\0\0\0" + "dht.HandshakeRequest" + "version" + }}, +}; +void HandshakeRequest::InternalSwap(HandshakeRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HandshakeRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[21]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HandshakeResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_._has_bits_); - static const ::dht::PeerDescriptor& sourcepeerdescriptor(const HandshakeResponse* msg); - static void set_has_sourcepeerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_error(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& HandshakeResponse::_Internal::sourcepeerdescriptor(const HandshakeResponse* msg) { - return *msg->_impl_.sourcepeerdescriptor_; -} -HandshakeResponse::HandshakeResponse(::google::protobuf::Arena* arena) +HandshakeResponse::HandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.HandshakeResponse) } -inline PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::HandshakeResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, version_(arena, from.version_) {} HandshakeResponse::HandshakeResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, HandshakeResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE HandshakeResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcepeerdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcepeerdescriptor_) + _impl_.sourcepeerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcepeerdescriptor_) : nullptr; _impl_.error_ = from._impl_.error_; // @@protoc_insertion_point(copy_constructor:dht.HandshakeResponse) } -inline PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE HandshakeResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, version_(arena) {} -inline void HandshakeResponse::SharedCtor(::_pb::Arena* arena) { +inline void HandshakeResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcepeerdescriptor_), 0, offsetof(Impl_, error_) - @@ -3299,82 +5587,139 @@ inline void HandshakeResponse::SharedCtor(::_pb::Arena* arena) { } HandshakeResponse::~HandshakeResponse() { // @@protoc_insertion_point(destructor:dht.HandshakeResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void HandshakeResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.version_.Destroy(); - delete _impl_.sourcepeerdescriptor_; - _impl_.~Impl_(); +inline void HandshakeResponse::SharedDtor(MessageLite& self) { + HandshakeResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.version_.Destroy(); + delete this_._impl_.sourcepeerdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL HandshakeResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) HandshakeResponse(arena); +} +constexpr auto HandshakeResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(HandshakeResponse), + alignof(HandshakeResponse)); +} +constexpr auto HandshakeResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_HandshakeResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &HandshakeResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &HandshakeResponse::SharedDtor, + static_cast(&HandshakeResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_._cached_size_), + false, + }, + &HandshakeResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* HandshakeResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void HandshakeResponse::InternalSwap(HandshakeResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull HandshakeResponse_class_data_ = + HandshakeResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +HandshakeResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&HandshakeResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(HandshakeResponse_class_data_.tc_table); + return HandshakeResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 37, 2> +HandshakeResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _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), + HandshakeResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::HandshakeResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.sourcepeerdescriptor_)}}, + // optional .dht.HandshakeError error = 2; + {::_pbi::TcParser::FastV32S1, + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.error_)}}, + // string version = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.version_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.PeerDescriptor sourcePeerDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.sourcepeerdescriptor_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .dht.HandshakeError error = 2; + {PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.error_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // string version = 3; + {PROTOBUF_FIELD_OFFSET(HandshakeResponse, _impl_.version_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\25\0\0\7\0\0\0\0" + "dht.HandshakeResponse" + "version" + }}, +}; +void HandshakeResponse::InternalSwap(HandshakeResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata HandshakeResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[22]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Message::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(Message, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(Message, _impl_._has_bits_); static constexpr ::int32_t kOneofCaseOffset = - PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_); - static const ::dht::PeerDescriptor& sourcedescriptor(const Message* msg); - static void set_has_sourcedescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::dht::PeerDescriptor& targetdescriptor(const Message* msg); - static void set_has_targetdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::protorpc::RpcMessage& rpcmessage(const Message* msg); - static const ::dht::ConnectivityRequest& connectivityrequest(const Message* msg); - static const ::dht::ConnectivityResponse& connectivityresponse(const Message* msg); - static const ::dht::HandshakeRequest& handshakerequest(const Message* msg); - static const ::dht::HandshakeResponse& handshakeresponse(const Message* msg); - static const ::dht::RecursiveOperationRequest& recursiveoperationrequest(const Message* msg); + PROTOBUF_FIELD_OFFSET(::dht::Message, _impl_._oneof_case_); }; -const ::dht::PeerDescriptor& Message::_Internal::sourcedescriptor(const Message* msg) { - return *msg->_impl_.sourcedescriptor_; -} -const ::dht::PeerDescriptor& Message::_Internal::targetdescriptor(const Message* msg) { - return *msg->_impl_.targetdescriptor_; -} -const ::protorpc::RpcMessage& Message::_Internal::rpcmessage(const Message* msg) { - return *msg->_impl_.body_.rpcmessage_; -} -const ::dht::ConnectivityRequest& Message::_Internal::connectivityrequest(const Message* msg) { - return *msg->_impl_.body_.connectivityrequest_; -} -const ::dht::ConnectivityResponse& Message::_Internal::connectivityresponse(const Message* msg) { - return *msg->_impl_.body_.connectivityresponse_; -} -const ::dht::HandshakeRequest& Message::_Internal::handshakerequest(const Message* msg) { - return *msg->_impl_.body_.handshakerequest_; -} -const ::dht::HandshakeResponse& Message::_Internal::handshakeresponse(const Message* msg) { - return *msg->_impl_.body_.handshakeresponse_; -} -const ::dht::RecursiveOperationRequest& Message::_Internal::recursiveoperationrequest(const Message* msg) { - return *msg->_impl_.body_.recursiveoperationrequest_; -} -void Message::set_allocated_rpcmessage(::protorpc::RpcMessage* rpcmessage) { +void Message::set_allocated_rpcmessage(::protorpc::RpcMessage* PROTOBUF_NULLABLE rpcmessage) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (rpcmessage) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(rpcmessage)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(rpcmessage)->GetArena(); if (message_arena != submessage_arena) { rpcmessage = ::google::protobuf::internal::GetOwnedMessage(message_arena, rpcmessage, submessage_arena); } @@ -3384,15 +5729,17 @@ void Message::set_allocated_rpcmessage(::protorpc::RpcMessage* rpcmessage) { // @@protoc_insertion_point(field_set_allocated:dht.Message.rpcMessage) } void Message::clear_rpcmessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kRpcMessage) { if (GetArena() == nullptr) { delete _impl_.body_.rpcmessage_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.rpcmessage_); } clear_has_body(); } } -void Message::set_allocated_connectivityrequest(::dht::ConnectivityRequest* connectivityrequest) { +void Message::set_allocated_connectivityrequest(::dht::ConnectivityRequest* PROTOBUF_NULLABLE connectivityrequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (connectivityrequest) { @@ -3405,7 +5752,7 @@ void Message::set_allocated_connectivityrequest(::dht::ConnectivityRequest* conn } // @@protoc_insertion_point(field_set_allocated:dht.Message.connectivityRequest) } -void Message::set_allocated_connectivityresponse(::dht::ConnectivityResponse* connectivityresponse) { +void Message::set_allocated_connectivityresponse(::dht::ConnectivityResponse* PROTOBUF_NULLABLE connectivityresponse) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (connectivityresponse) { @@ -3418,7 +5765,7 @@ void Message::set_allocated_connectivityresponse(::dht::ConnectivityResponse* co } // @@protoc_insertion_point(field_set_allocated:dht.Message.connectivityResponse) } -void Message::set_allocated_handshakerequest(::dht::HandshakeRequest* handshakerequest) { +void Message::set_allocated_handshakerequest(::dht::HandshakeRequest* PROTOBUF_NULLABLE handshakerequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (handshakerequest) { @@ -3431,7 +5778,7 @@ void Message::set_allocated_handshakerequest(::dht::HandshakeRequest* handshaker } // @@protoc_insertion_point(field_set_allocated:dht.Message.handshakeRequest) } -void Message::set_allocated_handshakeresponse(::dht::HandshakeResponse* handshakeresponse) { +void Message::set_allocated_handshakeresponse(::dht::HandshakeResponse* PROTOBUF_NULLABLE handshakeresponse) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (handshakeresponse) { @@ -3444,7 +5791,7 @@ void Message::set_allocated_handshakeresponse(::dht::HandshakeResponse* handshak } // @@protoc_insertion_point(field_set_allocated:dht.Message.handshakeResponse) } -void Message::set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* recursiveoperationrequest) { +void Message::set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE recursiveoperationrequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (recursiveoperationrequest) { @@ -3457,14 +5804,19 @@ void Message::set_allocated_recursiveoperationrequest(::dht::RecursiveOperationR } // @@protoc_insertion_point(field_set_allocated:dht.Message.recursiveOperationRequest) } -Message::Message(::google::protobuf::Arena* arena) +Message::Message(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Message_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.Message) } -inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::Message& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, messageid_(arena, from.messageid_), @@ -3473,58 +5825,62 @@ inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( _oneof_case_{from._oneof_case_[0]} {} Message::Message( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Message& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Message_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE Message* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.sourcedescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.sourcedescriptor_) + _impl_.sourcedescriptor_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.sourcedescriptor_) : nullptr; - _impl_.targetdescriptor_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.targetdescriptor_) + _impl_.targetdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.targetdescriptor_) : nullptr; switch (body_case()) { case BODY_NOT_SET: break; case kRpcMessage: - _impl_.body_.rpcmessage_ = CreateMaybeMessage<::protorpc::RpcMessage>(arena, *from._impl_.body_.rpcmessage_); + _impl_.body_.rpcmessage_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.rpcmessage_); break; case kConnectivityRequest: - _impl_.body_.connectivityrequest_ = CreateMaybeMessage<::dht::ConnectivityRequest>(arena, *from._impl_.body_.connectivityrequest_); + _impl_.body_.connectivityrequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.connectivityrequest_); break; case kConnectivityResponse: - _impl_.body_.connectivityresponse_ = CreateMaybeMessage<::dht::ConnectivityResponse>(arena, *from._impl_.body_.connectivityresponse_); + _impl_.body_.connectivityresponse_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.connectivityresponse_); break; case kHandshakeRequest: - _impl_.body_.handshakerequest_ = CreateMaybeMessage<::dht::HandshakeRequest>(arena, *from._impl_.body_.handshakerequest_); + _impl_.body_.handshakerequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.handshakerequest_); break; case kHandshakeResponse: - _impl_.body_.handshakeresponse_ = CreateMaybeMessage<::dht::HandshakeResponse>(arena, *from._impl_.body_.handshakeresponse_); + _impl_.body_.handshakeresponse_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.handshakeresponse_); break; case kRecursiveOperationRequest: - _impl_.body_.recursiveoperationrequest_ = CreateMaybeMessage<::dht::RecursiveOperationRequest>(arena, *from._impl_.body_.recursiveoperationrequest_); + _impl_.body_.recursiveoperationrequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.recursiveoperationrequest_); break; } // @@protoc_insertion_point(copy_constructor:dht.Message) } -inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, messageid_(arena), serviceid_(arena), body_{}, _oneof_case_{} {} -inline void Message::SharedCtor(::_pb::Arena* arena) { +inline void Message::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sourcedescriptor_), 0, offsetof(Impl_, targetdescriptor_) - @@ -3533,58 +5889,74 @@ inline void Message::SharedCtor(::_pb::Arena* arena) { } Message::~Message() { // @@protoc_insertion_point(destructor:dht.Message) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); -} -inline void Message::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.messageid_.Destroy(); - _impl_.serviceid_.Destroy(); - delete _impl_.sourcedescriptor_; - delete _impl_.targetdescriptor_; - if (has_body()) { - clear_body(); + SharedDtor(*this); +} +inline void Message::SharedDtor(MessageLite& self) { + Message& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); } - _impl_.~Impl_(); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.messageid_.Destroy(); + this_._impl_.serviceid_.Destroy(); + delete this_._impl_.sourcedescriptor_; + delete this_._impl_.targetdescriptor_; + if (this_.has_body()) { + this_.clear_body(); + } + this_._impl_.~Impl_(); } void Message::clear_body() { // @@protoc_insertion_point(one_of_clear_start:dht.Message) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); switch (body_case()) { case kRpcMessage: { if (GetArena() == nullptr) { delete _impl_.body_.rpcmessage_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.rpcmessage_); } break; } case kConnectivityRequest: { if (GetArena() == nullptr) { delete _impl_.body_.connectivityrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityrequest_); } break; } case kConnectivityResponse: { if (GetArena() == nullptr) { delete _impl_.body_.connectivityresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityresponse_); } break; } case kHandshakeRequest: { if (GetArena() == nullptr) { delete _impl_.body_.handshakerequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakerequest_); } break; } case kHandshakeResponse: { if (GetArena() == nullptr) { delete _impl_.body_.handshakeresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakeresponse_); } break; } case kRecursiveOperationRequest: { if (GetArena() == nullptr) { delete _impl_.body_.recursiveoperationrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.recursiveoperationrequest_); } break; } @@ -3596,17 +5968,132 @@ void Message::clear_body() { } -::_pbi::CachedSize* Message::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL Message::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) Message(arena); +} +constexpr auto Message::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Message), + alignof(Message)); +} +constexpr auto Message::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_Message_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Message::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Message::SharedDtor, + static_cast(&Message::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Message, _impl_._cached_size_), + false, + }, + &Message::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void Message::InternalSwap(Message* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull Message_class_data_ = + Message::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +Message::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&Message_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(Message_class_data_.tc_table); + return Message_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 10, 8, 46, 2> +Message::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Message, _impl_._has_bits_), + 0, // no _extensions_ + 10, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966272, // skipmap + offsetof(decltype(_table_), field_entries), + 10, // num_field_entries + 8, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + Message_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::Message>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string serviceId = 4; + {::_pbi::TcParser::FastUS1, + {34, 1, 0, + PROTOBUF_FIELD_OFFSET(Message, _impl_.serviceid_)}}, + // string messageId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(Message, _impl_.messageid_)}}, + // .dht.PeerDescriptor sourceDescriptor = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(Message, _impl_.sourcedescriptor_)}}, + // .dht.PeerDescriptor targetDescriptor = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 1, + PROTOBUF_FIELD_OFFSET(Message, _impl_.targetdescriptor_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string messageId = 1; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.messageid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .dht.PeerDescriptor sourceDescriptor = 2; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.sourcedescriptor_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.PeerDescriptor targetDescriptor = 3; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.targetdescriptor_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string serviceId = 4; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.serviceid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .protorpc.RpcMessage rpcMessage = 5; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.rpcmessage_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityRequest connectivityRequest = 6; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.connectivityrequest_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.ConnectivityResponse connectivityResponse = 7; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.connectivityresponse_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.HandshakeRequest handshakeRequest = 8; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.handshakerequest_), _Internal::kOneofCaseOffset + 0, 5, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.HandshakeResponse handshakeResponse = 9; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.handshakeresponse_), _Internal::kOneofCaseOffset + 0, 6, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dht.RecursiveOperationRequest recursiveOperationRequest = 10; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.body_.recursiveoperationrequest_), _Internal::kOneofCaseOffset + 0, 7, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::protorpc::RpcMessage>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityRequest>()}, + {::_pbi::TcParser::GetTable<::dht::ConnectivityResponse>()}, + {::_pbi::TcParser::GetTable<::dht::HandshakeRequest>()}, + {::_pbi::TcParser::GetTable<::dht::HandshakeResponse>()}, + {::_pbi::TcParser::GetTable<::dht::RecursiveOperationRequest>()}, + }}, + {{ + "\13\11\0\0\11\0\0\0\0\0\0\0\0\0\0\0" + "dht.Message" + "messageId" + "serviceId" + }}, +}; +void Message::InternalSwap(Message* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata Message::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[23]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -3614,14 +6101,22 @@ class WebsocketConnectionRequest::_Internal { public: }; -WebsocketConnectionRequest::WebsocketConnectionRequest(::google::protobuf::Arena* arena) +WebsocketConnectionRequest::WebsocketConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebsocketConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.WebsocketConnectionRequest) } WebsocketConnectionRequest::WebsocketConnectionRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebsocketConnectionRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebsocketConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE WebsocketConnectionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -3630,11 +6125,79 @@ WebsocketConnectionRequest::WebsocketConnectionRequest( // @@protoc_insertion_point(copy_constructor:dht.WebsocketConnectionRequest) } +inline void* PROTOBUF_NONNULL WebsocketConnectionRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) WebsocketConnectionRequest(arena); +} +constexpr auto WebsocketConnectionRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WebsocketConnectionRequest), + alignof(WebsocketConnectionRequest)); +} +constexpr auto WebsocketConnectionRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_WebsocketConnectionRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &WebsocketConnectionRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &WebsocketConnectionRequest::SharedDtor, + static_cast(&WebsocketConnectionRequest::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(WebsocketConnectionRequest, _impl_._cached_size_), + false, + }, + &WebsocketConnectionRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull WebsocketConnectionRequest_class_data_ = + WebsocketConnectionRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +WebsocketConnectionRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WebsocketConnectionRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WebsocketConnectionRequest_class_data_.tc_table); + return WebsocketConnectionRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +WebsocketConnectionRequest::_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 + WebsocketConnectionRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::WebsocketConnectionRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata WebsocketConnectionRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[24]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -3642,14 +6205,22 @@ class WebrtcConnectionRequest::_Internal { public: }; -WebrtcConnectionRequest::WebrtcConnectionRequest(::google::protobuf::Arena* arena) +WebrtcConnectionRequest::WebrtcConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebrtcConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:dht.WebrtcConnectionRequest) } WebrtcConnectionRequest::WebrtcConnectionRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebrtcConnectionRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, WebrtcConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE WebrtcConnectionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -3658,543 +6229,1479 @@ WebrtcConnectionRequest::WebrtcConnectionRequest( // @@protoc_insertion_point(copy_constructor:dht.WebrtcConnectionRequest) } +inline void* PROTOBUF_NONNULL WebrtcConnectionRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) WebrtcConnectionRequest(arena); +} +constexpr auto WebrtcConnectionRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WebrtcConnectionRequest), + alignof(WebrtcConnectionRequest)); +} +constexpr auto WebrtcConnectionRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_WebrtcConnectionRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &WebrtcConnectionRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &WebrtcConnectionRequest::SharedDtor, + static_cast(&WebrtcConnectionRequest::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(WebrtcConnectionRequest, _impl_._cached_size_), + false, + }, + &WebrtcConnectionRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull WebrtcConnectionRequest_class_data_ = + WebrtcConnectionRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +WebrtcConnectionRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WebrtcConnectionRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WebrtcConnectionRequest_class_data_.tc_table); + return WebrtcConnectionRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +WebrtcConnectionRequest::_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 + WebrtcConnectionRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::WebrtcConnectionRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata WebrtcConnectionRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[25]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RtcOffer::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_._has_bits_); }; -RtcOffer::RtcOffer(::google::protobuf::Arena* arena) +RtcOffer::RtcOffer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcOffer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RtcOffer) } -inline PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : description_(arena, from.description_), - connectionid_(arena, from.connectionid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RtcOffer& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + description_(arena, from.description_), + connectionid_(arena, from.connectionid_) {} RtcOffer::RtcOffer( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcOffer& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcOffer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RtcOffer* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.RtcOffer) } -inline PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : description_(arena), - connectionid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcOffer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + description_(arena), + connectionid_(arena) {} -inline void RtcOffer::SharedCtor(::_pb::Arena* arena) { +inline void RtcOffer::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RtcOffer::~RtcOffer() { // @@protoc_insertion_point(destructor:dht.RtcOffer) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RtcOffer::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.description_.Destroy(); - _impl_.connectionid_.Destroy(); - _impl_.~Impl_(); +inline void RtcOffer::SharedDtor(MessageLite& self) { + RtcOffer& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.description_.Destroy(); + this_._impl_.connectionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RtcOffer::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RtcOffer(arena); +} +constexpr auto RtcOffer::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RtcOffer), + alignof(RtcOffer)); +} +constexpr auto RtcOffer::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RtcOffer_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RtcOffer::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RtcOffer::SharedDtor, + static_cast(&RtcOffer::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_._cached_size_), + false, + }, + &RtcOffer::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RtcOffer::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RtcOffer::InternalSwap(RtcOffer* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RtcOffer_class_data_ = + RtcOffer::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RtcOffer::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RtcOffer_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RtcOffer_class_data_.tc_table); + return RtcOffer_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 44, 2> +RtcOffer::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_._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 + RtcOffer_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RtcOffer>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string connectionId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.connectionid_)}}, + // string description = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.description_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string description = 1; + {PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.description_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string connectionId = 2; + {PROTOBUF_FIELD_OFFSET(RtcOffer, _impl_.connectionid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\14\13\14\0\0\0\0\0" + "dht.RtcOffer" + "description" + "connectionId" + }}, +}; +void RtcOffer::InternalSwap(RtcOffer* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RtcOffer::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[26]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RtcAnswer::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_._has_bits_); }; -RtcAnswer::RtcAnswer(::google::protobuf::Arena* arena) +RtcAnswer::RtcAnswer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcAnswer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.RtcAnswer) } -inline PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : description_(arena, from.description_), - connectionid_(arena, from.connectionid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::RtcAnswer& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + description_(arena, from.description_), + connectionid_(arena, from.connectionid_) {} RtcAnswer::RtcAnswer( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcAnswer& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RtcAnswer_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RtcAnswer* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.RtcAnswer) } -inline PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : description_(arena), - connectionid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE RtcAnswer::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + description_(arena), + connectionid_(arena) {} -inline void RtcAnswer::SharedCtor(::_pb::Arena* arena) { +inline void RtcAnswer::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RtcAnswer::~RtcAnswer() { // @@protoc_insertion_point(destructor:dht.RtcAnswer) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RtcAnswer::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.description_.Destroy(); - _impl_.connectionid_.Destroy(); - _impl_.~Impl_(); +inline void RtcAnswer::SharedDtor(MessageLite& self) { + RtcAnswer& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.description_.Destroy(); + this_._impl_.connectionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RtcAnswer::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RtcAnswer(arena); +} +constexpr auto RtcAnswer::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RtcAnswer), + alignof(RtcAnswer)); +} +constexpr auto RtcAnswer::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RtcAnswer_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RtcAnswer::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RtcAnswer::SharedDtor, + static_cast(&RtcAnswer::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_._cached_size_), + false, + }, + &RtcAnswer::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* RtcAnswer::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void RtcAnswer::InternalSwap(RtcAnswer* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RtcAnswer_class_data_ = + RtcAnswer::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RtcAnswer::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RtcAnswer_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RtcAnswer_class_data_.tc_table); + return RtcAnswer_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 45, 2> +RtcAnswer::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_._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 + RtcAnswer_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::RtcAnswer>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string connectionId = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.connectionid_)}}, + // string description = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.description_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string description = 1; + {PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.description_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string connectionId = 2; + {PROTOBUF_FIELD_OFFSET(RtcAnswer, _impl_.connectionid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\15\13\14\0\0\0\0\0" + "dht.RtcAnswer" + "description" + "connectionId" + }}, +}; +void RtcAnswer::InternalSwap(RtcAnswer* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RtcAnswer::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[27]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class IceCandidate::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_._has_bits_); }; -IceCandidate::IceCandidate(::google::protobuf::Arena* arena) +IceCandidate::IceCandidate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, IceCandidate_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.IceCandidate) } -inline PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : candidate_(arena, from.candidate_), +PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::IceCandidate& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + candidate_(arena, from.candidate_), mid_(arena, from.mid_), - connectionid_(arena, from.connectionid_), - _cached_size_{0} {} + connectionid_(arena, from.connectionid_) {} IceCandidate::IceCandidate( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IceCandidate& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, IceCandidate_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE IceCandidate* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.IceCandidate) } -inline PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : candidate_(arena), +PROTOBUF_NDEBUG_INLINE IceCandidate::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + candidate_(arena), mid_(arena), - connectionid_(arena), - _cached_size_{0} {} + connectionid_(arena) {} -inline void IceCandidate::SharedCtor(::_pb::Arena* arena) { +inline void IceCandidate::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } IceCandidate::~IceCandidate() { // @@protoc_insertion_point(destructor:dht.IceCandidate) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void IceCandidate::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.candidate_.Destroy(); - _impl_.mid_.Destroy(); - _impl_.connectionid_.Destroy(); - _impl_.~Impl_(); +inline void IceCandidate::SharedDtor(MessageLite& self) { + IceCandidate& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.candidate_.Destroy(); + this_._impl_.mid_.Destroy(); + this_._impl_.connectionid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL IceCandidate::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) IceCandidate(arena); +} +constexpr auto IceCandidate::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(IceCandidate), + alignof(IceCandidate)); +} +constexpr auto IceCandidate::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_IceCandidate_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IceCandidate::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IceCandidate::SharedDtor, + static_cast(&IceCandidate::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_._cached_size_), + false, + }, + &IceCandidate::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* IceCandidate::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void IceCandidate::InternalSwap(IceCandidate* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull IceCandidate_class_data_ = + IceCandidate::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +IceCandidate::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&IceCandidate_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(IceCandidate_class_data_.tc_table); + return IceCandidate_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 49, 2> +IceCandidate::_table_ = { + { + PROTOBUF_FIELD_OFFSET(IceCandidate, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + IceCandidate_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::IceCandidate>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string candidate = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.candidate_)}}, + // string mid = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.mid_)}}, + // string connectionId = 3; + {::_pbi::TcParser::FastUS1, + {26, 2, 0, + PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.connectionid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string candidate = 1; + {PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.candidate_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string mid = 2; + {PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.mid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string connectionId = 3; + {PROTOBUF_FIELD_OFFSET(IceCandidate, _impl_.connectionid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\20\11\3\14\0\0\0\0" + "dht.IceCandidate" + "candidate" + "mid" + "connectionId" + }}, +}; +void IceCandidate::InternalSwap(IceCandidate* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata IceCandidate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[28]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class LockRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(LockRequest, _impl_._has_bits_); }; -LockRequest::LockRequest(::google::protobuf::Arena* arena) +LockRequest::LockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.LockRequest) } -inline PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : lockid_(arena, from.lockid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::LockRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + lockid_(arena, from.lockid_) {} LockRequest::LockRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE LockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.LockRequest) } -inline PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : lockid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE LockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + lockid_(arena) {} -inline void LockRequest::SharedCtor(::_pb::Arena* arena) { +inline void LockRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } LockRequest::~LockRequest() { // @@protoc_insertion_point(destructor:dht.LockRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void LockRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.lockid_.Destroy(); - _impl_.~Impl_(); +inline void LockRequest::SharedDtor(MessageLite& self) { + LockRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.lockid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL LockRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LockRequest(arena); +} +constexpr auto LockRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(LockRequest), + alignof(LockRequest)); +} +constexpr auto LockRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LockRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LockRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LockRequest::SharedDtor, + static_cast(&LockRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LockRequest, _impl_._cached_size_), + false, + }, + &LockRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* LockRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void LockRequest::InternalSwap(LockRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LockRequest_class_data_ = + LockRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LockRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LockRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LockRequest_class_data_.tc_table); + return LockRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 30, 2> +LockRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(LockRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + LockRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::LockRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string lockId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(LockRequest, _impl_.lockid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string lockId = 1; + {PROTOBUF_FIELD_OFFSET(LockRequest, _impl_.lockid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\17\6\0\0\0\0\0\0" + "dht.LockRequest" + "lockId" + }}, +}; +void LockRequest::InternalSwap(LockRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata LockRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[29]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class UnlockRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_._has_bits_); }; -UnlockRequest::UnlockRequest(::google::protobuf::Arena* arena) +UnlockRequest::UnlockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, UnlockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.UnlockRequest) } -inline PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : lockid_(arena, from.lockid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::UnlockRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + lockid_(arena, from.lockid_) {} UnlockRequest::UnlockRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const UnlockRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, UnlockRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE UnlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.UnlockRequest) } -inline PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : lockid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE UnlockRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + lockid_(arena) {} -inline void UnlockRequest::SharedCtor(::_pb::Arena* arena) { +inline void UnlockRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } UnlockRequest::~UnlockRequest() { // @@protoc_insertion_point(destructor:dht.UnlockRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void UnlockRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.lockid_.Destroy(); - _impl_.~Impl_(); +inline void UnlockRequest::SharedDtor(MessageLite& self) { + UnlockRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.lockid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL UnlockRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) UnlockRequest(arena); +} +constexpr auto UnlockRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(UnlockRequest), + alignof(UnlockRequest)); +} +constexpr auto UnlockRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_UnlockRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UnlockRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UnlockRequest::SharedDtor, + static_cast(&UnlockRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_._cached_size_), + false, + }, + &UnlockRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* UnlockRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void UnlockRequest::InternalSwap(UnlockRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull UnlockRequest_class_data_ = + UnlockRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +UnlockRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&UnlockRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(UnlockRequest_class_data_.tc_table); + return UnlockRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 32, 2> +UnlockRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(UnlockRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + UnlockRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::UnlockRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string lockId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_.lockid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string lockId = 1; + {PROTOBUF_FIELD_OFFSET(UnlockRequest, _impl_.lockid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\21\6\0\0\0\0\0\0" + "dht.UnlockRequest" + "lockId" + }}, +}; +void UnlockRequest::InternalSwap(UnlockRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata UnlockRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[30]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class LockResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(LockResponse, _impl_._has_bits_); }; -LockResponse::LockResponse(::google::protobuf::Arena* arena) +LockResponse::LockResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.LockResponse) } LockResponse::LockResponse( - ::google::protobuf::Arena* arena, const LockResponse& from) - : LockResponse(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LockResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE LockResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE LockResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void LockResponse::SharedCtor(::_pb::Arena* arena) { +inline void LockResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.accepted_ = {}; } LockResponse::~LockResponse() { // @@protoc_insertion_point(destructor:dht.LockResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void LockResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void LockResponse::SharedDtor(MessageLite& self) { + LockResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL LockResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LockResponse(arena); +} +constexpr auto LockResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(LockResponse), + alignof(LockResponse)); +} +constexpr auto LockResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LockResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LockResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LockResponse::SharedDtor, + static_cast(&LockResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LockResponse, _impl_._cached_size_), + false, + }, + &LockResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* LockResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void LockResponse::InternalSwap(LockResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LockResponse_class_data_ = + LockResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LockResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LockResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LockResponse_class_data_.tc_table); + return LockResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +LockResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(LockResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + LockResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::LockResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool accepted = 1; + {::_pbi::TcParser::FastV8S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(LockResponse, _impl_.accepted_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool accepted = 1; + {PROTOBUF_FIELD_OFFSET(LockResponse, _impl_.accepted_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; +void LockResponse::InternalSwap(LockResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata LockResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[31]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class DisconnectNotice::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_._has_bits_); }; -DisconnectNotice::DisconnectNotice(::google::protobuf::Arena* arena) +DisconnectNotice::DisconnectNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DisconnectNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.DisconnectNotice) } DisconnectNotice::DisconnectNotice( - ::google::protobuf::Arena* arena, const DisconnectNotice& from) - : DisconnectNotice(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DisconnectNotice& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, DisconnectNotice_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE DisconnectNotice::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE DisconnectNotice::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void DisconnectNotice::SharedCtor(::_pb::Arena* arena) { +inline void DisconnectNotice::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.disconnectmode_ = {}; } DisconnectNotice::~DisconnectNotice() { // @@protoc_insertion_point(destructor:dht.DisconnectNotice) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void DisconnectNotice::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void DisconnectNotice::SharedDtor(MessageLite& self) { + DisconnectNotice& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL DisconnectNotice::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) DisconnectNotice(arena); +} +constexpr auto DisconnectNotice::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DisconnectNotice), + alignof(DisconnectNotice)); +} +constexpr auto DisconnectNotice::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_DisconnectNotice_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DisconnectNotice::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DisconnectNotice::SharedDtor, + static_cast(&DisconnectNotice::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_._cached_size_), + false, + }, + &DisconnectNotice::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* DisconnectNotice::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void DisconnectNotice::InternalSwap(DisconnectNotice* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull DisconnectNotice_class_data_ = + DisconnectNotice::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +DisconnectNotice::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&DisconnectNotice_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(DisconnectNotice_class_data_.tc_table); + return DisconnectNotice_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +DisconnectNotice::_table_ = { + { + PROTOBUF_FIELD_OFFSET(DisconnectNotice, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + DisconnectNotice_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::DisconnectNotice>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.DisconnectMode disconnectMode = 1; + {::_pbi::TcParser::FastV32S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_.disconnectmode_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.DisconnectMode disconnectMode = 1; + {PROTOBUF_FIELD_OFFSET(DisconnectNotice, _impl_.disconnectmode_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + }}, +}; +void DisconnectNotice::InternalSwap(DisconnectNotice* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata DisconnectNotice::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[32]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalFetchDataRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_._has_bits_); }; -ExternalFetchDataRequest::ExternalFetchDataRequest(::google::protobuf::Arena* arena) +ExternalFetchDataRequest::ExternalFetchDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalFetchDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : key_(arena, from.key_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalFetchDataRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + key_(arena, from.key_) {} ExternalFetchDataRequest::ExternalFetchDataRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalFetchDataRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ExternalFetchDataRequest) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : key_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + key_(arena) {} -inline void ExternalFetchDataRequest::SharedCtor(::_pb::Arena* arena) { +inline void ExternalFetchDataRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExternalFetchDataRequest::~ExternalFetchDataRequest() { // @@protoc_insertion_point(destructor:dht.ExternalFetchDataRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalFetchDataRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.key_.Destroy(); - _impl_.~Impl_(); +inline void ExternalFetchDataRequest::SharedDtor(MessageLite& self) { + ExternalFetchDataRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.key_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalFetchDataRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalFetchDataRequest(arena); +} +constexpr auto ExternalFetchDataRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ExternalFetchDataRequest), + alignof(ExternalFetchDataRequest)); +} +constexpr auto ExternalFetchDataRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalFetchDataRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalFetchDataRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalFetchDataRequest::SharedDtor, + static_cast(&ExternalFetchDataRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_._cached_size_), + false, + }, + &ExternalFetchDataRequest::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ExternalFetchDataRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ExternalFetchDataRequest::InternalSwap(ExternalFetchDataRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalFetchDataRequest_class_data_ = + ExternalFetchDataRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalFetchDataRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalFetchDataRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalFetchDataRequest_class_data_.tc_table); + return ExternalFetchDataRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +ExternalFetchDataRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ExternalFetchDataRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalFetchDataRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bytes key = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes key = 1; + {PROTOBUF_FIELD_OFFSET(ExternalFetchDataRequest, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + }}, +}; +void ExternalFetchDataRequest::InternalSwap(ExternalFetchDataRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalFetchDataRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[33]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExternalFetchDataResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_._has_bits_); }; -ExternalFetchDataResponse::ExternalFetchDataResponse(::google::protobuf::Arena* arena) +ExternalFetchDataResponse::ExternalFetchDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:dht.ExternalFetchDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : entries_{visibility, arena, from.entries_}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::dht::ExternalFetchDataResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + entries_{visibility, arena, from.entries_} {} ExternalFetchDataResponse::ExternalFetchDataResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ExternalFetchDataResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ExternalFetchDataResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:dht.ExternalFetchDataResponse) } -inline PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : entries_{visibility, arena}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ExternalFetchDataResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + entries_{visibility, arena} {} -inline void ExternalFetchDataResponse::SharedCtor(::_pb::Arena* arena) { +inline void ExternalFetchDataResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExternalFetchDataResponse::~ExternalFetchDataResponse() { // @@protoc_insertion_point(destructor:dht.ExternalFetchDataResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ExternalFetchDataResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void ExternalFetchDataResponse::SharedDtor(MessageLite& self) { + ExternalFetchDataResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ExternalFetchDataResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ExternalFetchDataResponse(arena); +} +constexpr auto ExternalFetchDataResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_.entries_) + + decltype(ExternalFetchDataResponse::_impl_.entries_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(ExternalFetchDataResponse), alignof(ExternalFetchDataResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ExternalFetchDataResponse::PlacementNew_, + sizeof(ExternalFetchDataResponse), + alignof(ExternalFetchDataResponse)); + } } - -::_pbi::CachedSize* ExternalFetchDataResponse::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ExternalFetchDataResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ExternalFetchDataResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ExternalFetchDataResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ExternalFetchDataResponse::SharedDtor, + static_cast(&ExternalFetchDataResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_._cached_size_), + false, + }, + &ExternalFetchDataResponse::kDescriptorMethods, + &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, + nullptr, // tracker + }; } -void ExternalFetchDataResponse::InternalSwap(ExternalFetchDataResponse* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ExternalFetchDataResponse_class_data_ = + ExternalFetchDataResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ExternalFetchDataResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExternalFetchDataResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExternalFetchDataResponse_class_data_.tc_table); + return ExternalFetchDataResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +ExternalFetchDataResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _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), + ExternalFetchDataResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dht::ExternalFetchDataResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.DataEntry entries = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_.entries_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.DataEntry entries = 1; + {PROTOBUF_FIELD_OFFSET(ExternalFetchDataResponse, _impl_.entries_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::DataEntry>()}, + }}, + {{ + }}, +}; +void ExternalFetchDataResponse::InternalSwap(ExternalFetchDataResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ExternalFetchDataResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_getter, &descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto_once, - file_level_metadata_packages_2fdht_2fprotos_2fDhtRpc_2eproto[34]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace dht @@ -4203,4 +7710,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.h b/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.h index 6d11615b..da1456b5 100644 --- a/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.h +++ b/packages/streamr-trackerless-network/src/proto/packages/dht/protos/DhtRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/dht/protos/DhtRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh +#ifndef packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh +#define packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -31,6 +25,7 @@ #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/generated_enum_reflection.h" @@ -49,7 +44,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -58,117 +54,183 @@ class AnyMetadata; struct TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto; +} // extern "C" namespace dht { +enum DisconnectMode : int; +extern const uint32_t DisconnectMode_internal_data_[]; +enum HandshakeError : int; +extern const uint32_t HandshakeError_internal_data_[]; +enum NodeType : int; +extern const uint32_t NodeType_internal_data_[]; +enum RecursiveOperation : int; +extern const uint32_t RecursiveOperation_internal_data_[]; +enum RouteMessageError : int; +extern const uint32_t RouteMessageError_internal_data_[]; +enum RpcResponseError : int; +extern const uint32_t RpcResponseError_internal_data_[]; class ClosestPeersRequest; struct ClosestPeersRequestDefaultTypeInternal; extern ClosestPeersRequestDefaultTypeInternal _ClosestPeersRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_; class ClosestPeersResponse; struct ClosestPeersResponseDefaultTypeInternal; extern ClosestPeersResponseDefaultTypeInternal _ClosestPeersResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_; class ClosestRingPeersRequest; struct ClosestRingPeersRequestDefaultTypeInternal; extern ClosestRingPeersRequestDefaultTypeInternal _ClosestRingPeersRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersRequest_class_data_; class ClosestRingPeersResponse; struct ClosestRingPeersResponseDefaultTypeInternal; extern ClosestRingPeersResponseDefaultTypeInternal _ClosestRingPeersResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersResponse_class_data_; class ConnectivityMethod; struct ConnectivityMethodDefaultTypeInternal; extern ConnectivityMethodDefaultTypeInternal _ConnectivityMethod_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_; class ConnectivityRequest; struct ConnectivityRequestDefaultTypeInternal; extern ConnectivityRequestDefaultTypeInternal _ConnectivityRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityRequest_class_data_; class ConnectivityResponse; struct ConnectivityResponseDefaultTypeInternal; extern ConnectivityResponseDefaultTypeInternal _ConnectivityResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ConnectivityResponse_class_data_; class DataEntry; struct DataEntryDefaultTypeInternal; extern DataEntryDefaultTypeInternal _DataEntry_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull DataEntry_class_data_; class DisconnectNotice; struct DisconnectNoticeDefaultTypeInternal; extern DisconnectNoticeDefaultTypeInternal _DisconnectNotice_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull DisconnectNotice_class_data_; class ExternalFetchDataRequest; struct ExternalFetchDataRequestDefaultTypeInternal; extern ExternalFetchDataRequestDefaultTypeInternal _ExternalFetchDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataRequest_class_data_; class ExternalFetchDataResponse; struct ExternalFetchDataResponseDefaultTypeInternal; extern ExternalFetchDataResponseDefaultTypeInternal _ExternalFetchDataResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataResponse_class_data_; class ExternalStoreDataRequest; struct ExternalStoreDataRequestDefaultTypeInternal; extern ExternalStoreDataRequestDefaultTypeInternal _ExternalStoreDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataRequest_class_data_; class ExternalStoreDataResponse; struct ExternalStoreDataResponseDefaultTypeInternal; extern ExternalStoreDataResponseDefaultTypeInternal _ExternalStoreDataResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataResponse_class_data_; class HandshakeRequest; struct HandshakeRequestDefaultTypeInternal; extern HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HandshakeRequest_class_data_; class HandshakeResponse; struct HandshakeResponseDefaultTypeInternal; extern HandshakeResponseDefaultTypeInternal _HandshakeResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull HandshakeResponse_class_data_; class IceCandidate; struct IceCandidateDefaultTypeInternal; extern IceCandidateDefaultTypeInternal _IceCandidate_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull IceCandidate_class_data_; class LeaveNotice; struct LeaveNoticeDefaultTypeInternal; extern LeaveNoticeDefaultTypeInternal _LeaveNotice_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LeaveNotice_class_data_; class LockRequest; struct LockRequestDefaultTypeInternal; extern LockRequestDefaultTypeInternal _LockRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LockRequest_class_data_; class LockResponse; struct LockResponseDefaultTypeInternal; extern LockResponseDefaultTypeInternal _LockResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LockResponse_class_data_; class Message; struct MessageDefaultTypeInternal; extern MessageDefaultTypeInternal _Message_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull Message_class_data_; class PeerDescriptor; struct PeerDescriptorDefaultTypeInternal; extern PeerDescriptorDefaultTypeInternal _PeerDescriptor_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_; class PingRequest; struct PingRequestDefaultTypeInternal; extern PingRequestDefaultTypeInternal _PingRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PingRequest_class_data_; class PingResponse; struct PingResponseDefaultTypeInternal; extern PingResponseDefaultTypeInternal _PingResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull PingResponse_class_data_; class RecursiveOperationRequest; struct RecursiveOperationRequestDefaultTypeInternal; extern RecursiveOperationRequestDefaultTypeInternal _RecursiveOperationRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationRequest_class_data_; class RecursiveOperationResponse; struct RecursiveOperationResponseDefaultTypeInternal; extern RecursiveOperationResponseDefaultTypeInternal _RecursiveOperationResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationResponse_class_data_; class ReplicateDataRequest; struct ReplicateDataRequestDefaultTypeInternal; extern ReplicateDataRequestDefaultTypeInternal _ReplicateDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ReplicateDataRequest_class_data_; class RouteMessageAck; struct RouteMessageAckDefaultTypeInternal; extern RouteMessageAckDefaultTypeInternal _RouteMessageAck_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_; class RouteMessageWrapper; struct RouteMessageWrapperDefaultTypeInternal; extern RouteMessageWrapperDefaultTypeInternal _RouteMessageWrapper_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_; class RtcAnswer; struct RtcAnswerDefaultTypeInternal; extern RtcAnswerDefaultTypeInternal _RtcAnswer_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RtcAnswer_class_data_; class RtcOffer; struct RtcOfferDefaultTypeInternal; extern RtcOfferDefaultTypeInternal _RtcOffer_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RtcOffer_class_data_; class StoreDataRequest; struct StoreDataRequestDefaultTypeInternal; extern StoreDataRequestDefaultTypeInternal _StoreDataRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StoreDataRequest_class_data_; class StoreDataResponse; struct StoreDataResponseDefaultTypeInternal; extern StoreDataResponseDefaultTypeInternal _StoreDataResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StoreDataResponse_class_data_; class UnlockRequest; struct UnlockRequestDefaultTypeInternal; extern UnlockRequestDefaultTypeInternal _UnlockRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull UnlockRequest_class_data_; class WebrtcConnectionRequest; struct WebrtcConnectionRequestDefaultTypeInternal; extern WebrtcConnectionRequestDefaultTypeInternal _WebrtcConnectionRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WebrtcConnectionRequest_class_data_; class WebsocketConnectionRequest; struct WebsocketConnectionRequestDefaultTypeInternal; extern WebsocketConnectionRequestDefaultTypeInternal _WebsocketConnectionRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WebsocketConnectionRequest_class_data_; } // namespace dht namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::dht::DisconnectMode_internal_data_> + internal::EnumTraitsImpl::value<::dht::DisconnectMode>; +template <> +internal::EnumTraitsT<::dht::HandshakeError_internal_data_> + internal::EnumTraitsImpl::value<::dht::HandshakeError>; +template <> +internal::EnumTraitsT<::dht::NodeType_internal_data_> + internal::EnumTraitsImpl::value<::dht::NodeType>; +template <> +internal::EnumTraitsT<::dht::RecursiveOperation_internal_data_> + internal::EnumTraitsImpl::value<::dht::RecursiveOperation>; +template <> +internal::EnumTraitsT<::dht::RouteMessageError_internal_data_> + internal::EnumTraitsImpl::value<::dht::RouteMessageError>; +template <> +internal::EnumTraitsT<::dht::RpcResponseError_internal_data_> + internal::EnumTraitsImpl::value<::dht::RpcResponseError>; } // namespace protobuf } // namespace google @@ -178,67 +240,73 @@ enum RecursiveOperation : int { FETCH_DATA = 1, DELETE_DATA = 2, RecursiveOperation_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RecursiveOperation_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RecursiveOperation_IsValid(int value); extern const uint32_t RecursiveOperation_internal_data_[]; -constexpr RecursiveOperation RecursiveOperation_MIN = static_cast(0); -constexpr RecursiveOperation RecursiveOperation_MAX = static_cast(2); -constexpr int RecursiveOperation_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -RecursiveOperation_descriptor(); +inline constexpr RecursiveOperation RecursiveOperation_MIN = + static_cast(0); +inline constexpr RecursiveOperation RecursiveOperation_MAX = + static_cast(2); +inline bool RecursiveOperation_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int RecursiveOperation_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RecursiveOperation_descriptor(); template -const std::string& RecursiveOperation_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RecursiveOperation_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RecursiveOperation_Name()."); return RecursiveOperation_Name(static_cast(value)); } template <> -inline const std::string& RecursiveOperation_Name(RecursiveOperation value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RecursiveOperation_Name(RecursiveOperation value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RecursiveOperation_Parse(absl::string_view name, RecursiveOperation* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RecursiveOperation_descriptor(), name, value); +inline bool RecursiveOperation_Parse( + ::absl::string_view name, RecursiveOperation* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RecursiveOperation_descriptor(), name, + value); } enum NodeType : int { NODEJS = 0, BROWSER = 1, NodeType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), NodeType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool NodeType_IsValid(int value); extern const uint32_t NodeType_internal_data_[]; -constexpr NodeType NodeType_MIN = static_cast(0); -constexpr NodeType NodeType_MAX = static_cast(1); -constexpr int NodeType_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -NodeType_descriptor(); +inline constexpr NodeType NodeType_MIN = + static_cast(0); +inline constexpr NodeType NodeType_MAX = + static_cast(1); +inline bool NodeType_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int NodeType_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL NodeType_descriptor(); template -const std::string& NodeType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& NodeType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to NodeType_Name()."); return NodeType_Name(static_cast(value)); } template <> -inline const std::string& NodeType_Name(NodeType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& NodeType_Name(NodeType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool NodeType_Parse(absl::string_view name, NodeType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - NodeType_descriptor(), name, value); +inline bool NodeType_Parse( + ::absl::string_view name, NodeType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(NodeType_descriptor(), name, + value); } enum RpcResponseError : int { SERVER_TIMOUT = 0, @@ -246,135 +314,147 @@ enum RpcResponseError : int { SERVER_ERROR = 2, UNKNOWN_RPC_METHOD = 3, RpcResponseError_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RpcResponseError_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RpcResponseError_IsValid(int value); extern const uint32_t RpcResponseError_internal_data_[]; -constexpr RpcResponseError RpcResponseError_MIN = static_cast(0); -constexpr RpcResponseError RpcResponseError_MAX = static_cast(3); -constexpr int RpcResponseError_ARRAYSIZE = 3 + 1; -const ::google::protobuf::EnumDescriptor* -RpcResponseError_descriptor(); +inline constexpr RpcResponseError RpcResponseError_MIN = + static_cast(0); +inline constexpr RpcResponseError RpcResponseError_MAX = + static_cast(3); +inline bool RpcResponseError_IsValid(int value) { + return 0 <= value && value <= 3; +} +inline constexpr int RpcResponseError_ARRAYSIZE = 3 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcResponseError_descriptor(); template -const std::string& RpcResponseError_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RpcResponseError_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RpcResponseError_Name()."); return RpcResponseError_Name(static_cast(value)); } template <> -inline const std::string& RpcResponseError_Name(RpcResponseError value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RpcResponseError_Name(RpcResponseError value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RpcResponseError_Parse(absl::string_view name, RpcResponseError* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RpcResponseError_descriptor(), name, value); +inline bool RpcResponseError_Parse( + ::absl::string_view name, RpcResponseError* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RpcResponseError_descriptor(), name, + value); } enum RouteMessageError : int { NO_TARGETS = 0, DUPLICATE = 1, STOPPED = 2, RouteMessageError_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RouteMessageError_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RouteMessageError_IsValid(int value); extern const uint32_t RouteMessageError_internal_data_[]; -constexpr RouteMessageError RouteMessageError_MIN = static_cast(0); -constexpr RouteMessageError RouteMessageError_MAX = static_cast(2); -constexpr int RouteMessageError_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -RouteMessageError_descriptor(); +inline constexpr RouteMessageError RouteMessageError_MIN = + static_cast(0); +inline constexpr RouteMessageError RouteMessageError_MAX = + static_cast(2); +inline bool RouteMessageError_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int RouteMessageError_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RouteMessageError_descriptor(); template -const std::string& RouteMessageError_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RouteMessageError_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RouteMessageError_Name()."); return RouteMessageError_Name(static_cast(value)); } template <> -inline const std::string& RouteMessageError_Name(RouteMessageError value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RouteMessageError_Name(RouteMessageError value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RouteMessageError_Parse(absl::string_view name, RouteMessageError* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RouteMessageError_descriptor(), name, value); +inline bool RouteMessageError_Parse( + ::absl::string_view name, RouteMessageError* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RouteMessageError_descriptor(), name, + value); } enum HandshakeError : int { DUPLICATE_CONNECTION = 0, INVALID_TARGET_PEER_DESCRIPTOR = 1, UNSUPPORTED_VERSION = 2, HandshakeError_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), HandshakeError_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool HandshakeError_IsValid(int value); extern const uint32_t HandshakeError_internal_data_[]; -constexpr HandshakeError HandshakeError_MIN = static_cast(0); -constexpr HandshakeError HandshakeError_MAX = static_cast(2); -constexpr int HandshakeError_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -HandshakeError_descriptor(); +inline constexpr HandshakeError HandshakeError_MIN = + static_cast(0); +inline constexpr HandshakeError HandshakeError_MAX = + static_cast(2); +inline bool HandshakeError_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int HandshakeError_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL HandshakeError_descriptor(); template -const std::string& HandshakeError_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& HandshakeError_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to HandshakeError_Name()."); return HandshakeError_Name(static_cast(value)); } template <> -inline const std::string& HandshakeError_Name(HandshakeError value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& HandshakeError_Name(HandshakeError value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool HandshakeError_Parse(absl::string_view name, HandshakeError* value) { - return ::google::protobuf::internal::ParseNamedEnum( - HandshakeError_descriptor(), name, value); +inline bool HandshakeError_Parse( + ::absl::string_view name, HandshakeError* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(HandshakeError_descriptor(), name, + value); } enum DisconnectMode : int { NORMAL = 0, LEAVING = 1, DisconnectMode_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), DisconnectMode_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool DisconnectMode_IsValid(int value); extern const uint32_t DisconnectMode_internal_data_[]; -constexpr DisconnectMode DisconnectMode_MIN = static_cast(0); -constexpr DisconnectMode DisconnectMode_MAX = static_cast(1); -constexpr int DisconnectMode_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -DisconnectMode_descriptor(); +inline constexpr DisconnectMode DisconnectMode_MIN = + static_cast(0); +inline constexpr DisconnectMode DisconnectMode_MAX = + static_cast(1); +inline bool DisconnectMode_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int DisconnectMode_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DisconnectMode_descriptor(); template -const std::string& DisconnectMode_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& DisconnectMode_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to DisconnectMode_Name()."); return DisconnectMode_Name(static_cast(value)); } template <> -inline const std::string& DisconnectMode_Name(DisconnectMode value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& DisconnectMode_Name(DisconnectMode value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool DisconnectMode_Parse(absl::string_view name, DisconnectMode* value) { - return ::google::protobuf::internal::ParseNamedEnum( - DisconnectMode_descriptor(), name, value); +inline bool DisconnectMode_Parse( + ::absl::string_view name, DisconnectMode* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(DisconnectMode_descriptor(), name, + value); } // =================================================================== @@ -382,31 +462,31 @@ inline bool DisconnectMode_Parse(absl::string_view name, DisconnectMode* value) // ------------------------------------------------------------------- -class WebsocketConnectionRequest final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.WebsocketConnectionRequest) */ { +class WebsocketConnectionRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.WebsocketConnectionRequest) */ { public: inline WebsocketConnectionRequest() : WebsocketConnectionRequest(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR WebsocketConnectionRequest(::google::protobuf::internal::ConstantInitialized); - inline WebsocketConnectionRequest(const WebsocketConnectionRequest& from) - : WebsocketConnectionRequest(nullptr, from) {} - WebsocketConnectionRequest(WebsocketConnectionRequest&& from) noexcept - : WebsocketConnectionRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WebsocketConnectionRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WebsocketConnectionRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR WebsocketConnectionRequest(::google::protobuf::internal::ConstantInitialized); + inline WebsocketConnectionRequest(const WebsocketConnectionRequest& from) : WebsocketConnectionRequest(nullptr, from) {} + inline WebsocketConnectionRequest(WebsocketConnectionRequest&& from) noexcept + : WebsocketConnectionRequest(nullptr, ::std::move(from)) {} inline WebsocketConnectionRequest& operator=(const WebsocketConnectionRequest& from) { CopyFrom(from); return *this; } inline WebsocketConnectionRequest& operator=(WebsocketConnectionRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -418,47 +498,35 @@ class WebsocketConnectionRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const WebsocketConnectionRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_WebsocketConnectionRequest_default_instance_); } - static inline const WebsocketConnectionRequest* internal_default_instance() { - return reinterpret_cast( - &_WebsocketConnectionRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 24; - - friend void swap(WebsocketConnectionRequest& a, WebsocketConnectionRequest& b) { - a.Swap(&b); - } - inline void Swap(WebsocketConnectionRequest* other) { + static constexpr int kIndexInFileMessages = 24; + friend void swap(WebsocketConnectionRequest& a, WebsocketConnectionRequest& b) { a.Swap(&b); } + inline void Swap(WebsocketConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(WebsocketConnectionRequest* other) { + void UnsafeArenaSwap(WebsocketConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -466,29 +534,42 @@ class WebsocketConnectionRequest final : // implements Message ---------------------------------------------- - WebsocketConnectionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + WebsocketConnectionRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.WebsocketConnectionRequest"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.WebsocketConnectionRequest"; } + + explicit WebsocketConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WebsocketConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebsocketConnectionRequest& from); + WebsocketConnectionRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WebsocketConnectionRequest&& from) noexcept + : WebsocketConnectionRequest(arena) { + *this = ::std::move(from); } - protected: - explicit WebsocketConnectionRequest(::google::protobuf::Arena* arena); - WebsocketConnectionRequest(::google::protobuf::Arena* arena, const WebsocketConnectionRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.WebsocketConnectionRequest) 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; @@ -496,44 +577,37 @@ class WebsocketConnectionRequest final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull WebsocketConnectionRequest_class_data_; +// ------------------------------------------------------------------- -class WebrtcConnectionRequest final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.WebrtcConnectionRequest) */ { +class WebrtcConnectionRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.WebrtcConnectionRequest) */ { public: inline WebrtcConnectionRequest() : WebrtcConnectionRequest(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR WebrtcConnectionRequest(::google::protobuf::internal::ConstantInitialized); - inline WebrtcConnectionRequest(const WebrtcConnectionRequest& from) - : WebrtcConnectionRequest(nullptr, from) {} - WebrtcConnectionRequest(WebrtcConnectionRequest&& from) noexcept - : WebrtcConnectionRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WebrtcConnectionRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WebrtcConnectionRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR WebrtcConnectionRequest(::google::protobuf::internal::ConstantInitialized); + inline WebrtcConnectionRequest(const WebrtcConnectionRequest& from) : WebrtcConnectionRequest(nullptr, from) {} + inline WebrtcConnectionRequest(WebrtcConnectionRequest&& from) noexcept + : WebrtcConnectionRequest(nullptr, ::std::move(from)) {} inline WebrtcConnectionRequest& operator=(const WebrtcConnectionRequest& from) { CopyFrom(from); return *this; } inline WebrtcConnectionRequest& operator=(WebrtcConnectionRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -545,47 +619,35 @@ class WebrtcConnectionRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const WebrtcConnectionRequest& default_instance() { - return *internal_default_instance(); - } - static inline const WebrtcConnectionRequest* internal_default_instance() { - return reinterpret_cast( - &_WebrtcConnectionRequest_default_instance_); + return *reinterpret_cast( + &_WebrtcConnectionRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 25; - - friend void swap(WebrtcConnectionRequest& a, WebrtcConnectionRequest& b) { - a.Swap(&b); - } - inline void Swap(WebrtcConnectionRequest* other) { + static constexpr int kIndexInFileMessages = 25; + friend void swap(WebrtcConnectionRequest& a, WebrtcConnectionRequest& b) { a.Swap(&b); } + inline void Swap(WebrtcConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(WebrtcConnectionRequest* other) { + void UnsafeArenaSwap(WebrtcConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -593,29 +655,42 @@ class WebrtcConnectionRequest final : // implements Message ---------------------------------------------- - WebrtcConnectionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + WebrtcConnectionRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.WebrtcConnectionRequest"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.WebrtcConnectionRequest"; } + + explicit WebrtcConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WebrtcConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WebrtcConnectionRequest& from); + WebrtcConnectionRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WebrtcConnectionRequest&& from) noexcept + : WebrtcConnectionRequest(arena) { + *this = ::std::move(from); } - protected: - explicit WebrtcConnectionRequest(::google::protobuf::Arena* arena); - WebrtcConnectionRequest(::google::protobuf::Arena* arena, const WebrtcConnectionRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.WebrtcConnectionRequest) 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; @@ -623,45 +698,38 @@ class WebrtcConnectionRequest final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull WebrtcConnectionRequest_class_data_; +// ------------------------------------------------------------------- -class UnlockRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.UnlockRequest) */ { +class UnlockRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.UnlockRequest) */ { public: inline UnlockRequest() : UnlockRequest(nullptr) {} - ~UnlockRequest() override; - template - explicit PROTOBUF_CONSTEXPR UnlockRequest(::google::protobuf::internal::ConstantInitialized); + ~UnlockRequest() PROTOBUF_FINAL; - inline UnlockRequest(const UnlockRequest& from) - : UnlockRequest(nullptr, from) {} - UnlockRequest(UnlockRequest&& from) noexcept - : UnlockRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UnlockRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UnlockRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR UnlockRequest(::google::protobuf::internal::ConstantInitialized); + inline UnlockRequest(const UnlockRequest& from) : UnlockRequest(nullptr, from) {} + inline UnlockRequest(UnlockRequest&& from) noexcept + : UnlockRequest(nullptr, ::std::move(from)) {} inline UnlockRequest& operator=(const UnlockRequest& from) { CopyFrom(from); return *this; } inline UnlockRequest& operator=(UnlockRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -673,47 +741,35 @@ class UnlockRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const UnlockRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_UnlockRequest_default_instance_); } - static inline const UnlockRequest* internal_default_instance() { - return reinterpret_cast( - &_UnlockRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 30; - - friend void swap(UnlockRequest& a, UnlockRequest& b) { - a.Swap(&b); - } - inline void Swap(UnlockRequest* other) { + static constexpr int kIndexInFileMessages = 30; + friend void swap(UnlockRequest& a, UnlockRequest& b) { a.Swap(&b); } + inline void Swap(UnlockRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(UnlockRequest* other) { + void UnsafeArenaSwap(UnlockRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -721,55 +777,66 @@ class UnlockRequest final : // implements Message ---------------------------------------------- - UnlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + UnlockRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(UnlockRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.UnlockRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UnlockRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.UnlockRequest"; } + + explicit UnlockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + UnlockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const UnlockRequest& from); + UnlockRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, UnlockRequest&& from) noexcept + : UnlockRequest(arena) { + *this = ::std::move(from); } - protected: - explicit UnlockRequest(::google::protobuf::Arena* arena); - UnlockRequest(::google::protobuf::Arena* arena, const UnlockRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kLockIdFieldNumber = 1, }; // string lockId = 1; void clear_lockid() ; - const std::string& lockid() const; - template + const ::std::string& lockid() const; + template void set_lockid(Arg_&& arg, Args_... args); - std::string* mutable_lockid(); - PROTOBUF_NODISCARD std::string* release_lockid(); - void set_allocated_lockid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_lockid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_lockid(); + void set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_lockid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_lockid( - const std::string& value); - std::string* _internal_mutable_lockid(); + const ::std::string& _internal_lockid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_lockid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_lockid(); public: // @@protoc_insertion_point(class_scope:dht.UnlockRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 32, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -778,46 +845,51 @@ class UnlockRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const UnlockRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr lockid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull UnlockRequest_class_data_; +// ------------------------------------------------------------------- -class StoreDataResponse final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.StoreDataResponse) */ { +class StoreDataResponse final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.StoreDataResponse) */ { public: inline StoreDataResponse() : StoreDataResponse(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR StoreDataResponse(::google::protobuf::internal::ConstantInitialized); - inline StoreDataResponse(const StoreDataResponse& from) - : StoreDataResponse(nullptr, from) {} - StoreDataResponse(StoreDataResponse&& from) noexcept - : StoreDataResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StoreDataResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StoreDataResponse)); } +#endif + template + explicit PROTOBUF_CONSTEXPR StoreDataResponse(::google::protobuf::internal::ConstantInitialized); + + inline StoreDataResponse(const StoreDataResponse& from) : StoreDataResponse(nullptr, from) {} + inline StoreDataResponse(StoreDataResponse&& from) noexcept + : StoreDataResponse(nullptr, ::std::move(from)) {} inline StoreDataResponse& operator=(const StoreDataResponse& from) { CopyFrom(from); return *this; } inline StoreDataResponse& operator=(StoreDataResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -829,47 +901,35 @@ class StoreDataResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StoreDataResponse& default_instance() { - return *internal_default_instance(); - } - static inline const StoreDataResponse* internal_default_instance() { - return reinterpret_cast( - &_StoreDataResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(StoreDataResponse& a, StoreDataResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_StoreDataResponse_default_instance_); } - inline void Swap(StoreDataResponse* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(StoreDataResponse& a, StoreDataResponse& b) { a.Swap(&b); } + inline void Swap(StoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StoreDataResponse* other) { + void UnsafeArenaSwap(StoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -877,29 +937,42 @@ class StoreDataResponse final : // implements Message ---------------------------------------------- - StoreDataResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StoreDataResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.StoreDataResponse"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.StoreDataResponse"; } + + explicit StoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataResponse& from); + StoreDataResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StoreDataResponse&& from) noexcept + : StoreDataResponse(arena) { + *this = ::std::move(from); } - protected: - explicit StoreDataResponse(::google::protobuf::Arena* arena); - StoreDataResponse(::google::protobuf::Arena* arena, const StoreDataResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.StoreDataResponse) 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; @@ -907,45 +980,38 @@ class StoreDataResponse final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StoreDataResponse_class_data_; +// ------------------------------------------------------------------- -class RtcOffer final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RtcOffer) */ { +class RtcOffer final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RtcOffer) */ { public: inline RtcOffer() : RtcOffer(nullptr) {} - ~RtcOffer() override; - template - explicit PROTOBUF_CONSTEXPR RtcOffer(::google::protobuf::internal::ConstantInitialized); + ~RtcOffer() PROTOBUF_FINAL; - inline RtcOffer(const RtcOffer& from) - : RtcOffer(nullptr, from) {} - RtcOffer(RtcOffer&& from) noexcept - : RtcOffer() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RtcOffer* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RtcOffer)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RtcOffer(::google::protobuf::internal::ConstantInitialized); + + inline RtcOffer(const RtcOffer& from) : RtcOffer(nullptr, from) {} + inline RtcOffer(RtcOffer&& from) noexcept + : RtcOffer(nullptr, ::std::move(from)) {} inline RtcOffer& operator=(const RtcOffer& from) { CopyFrom(from); return *this; } inline RtcOffer& operator=(RtcOffer&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -957,47 +1023,35 @@ class RtcOffer final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RtcOffer& default_instance() { - return *internal_default_instance(); - } - static inline const RtcOffer* internal_default_instance() { - return reinterpret_cast( - &_RtcOffer_default_instance_); - } - static constexpr int kIndexInFileMessages = - 26; - - friend void swap(RtcOffer& a, RtcOffer& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RtcOffer_default_instance_); } - inline void Swap(RtcOffer* other) { + static constexpr int kIndexInFileMessages = 26; + friend void swap(RtcOffer& a, RtcOffer& b) { a.Swap(&b); } + inline void Swap(RtcOffer* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RtcOffer* other) { + void UnsafeArenaSwap(RtcOffer* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1005,72 +1059,82 @@ class RtcOffer final : // implements Message ---------------------------------------------- - RtcOffer* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RtcOffer* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RtcOffer* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RtcOffer"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RtcOffer* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RtcOffer"; } + + explicit RtcOffer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RtcOffer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcOffer& from); + RtcOffer( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RtcOffer&& from) noexcept + : RtcOffer(arena) { + *this = ::std::move(from); } - protected: - explicit RtcOffer(::google::protobuf::Arena* arena); - RtcOffer(::google::protobuf::Arena* arena, const RtcOffer& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kDescriptionFieldNumber = 1, kConnectionIdFieldNumber = 2, }; // string description = 1; void clear_description() ; - const std::string& description() const; - template + const ::std::string& description() const; + template void set_description(Arg_&& arg, Args_... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_description(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_description(); + void set_allocated_description(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description( - const std::string& value); - std::string* _internal_mutable_description(); + const ::std::string& _internal_description() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_description(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_description(); public: // string connectionId = 2; void clear_connectionid() ; - const std::string& connectionid() const; - template + const ::std::string& connectionid() const; + template void set_connectionid(Arg_&& arg, Args_... args); - std::string* mutable_connectionid(); - PROTOBUF_NODISCARD std::string* release_connectionid(); - void set_allocated_connectionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_connectionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_connectionid(); + void set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_connectionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid( - const std::string& value); - std::string* _internal_mutable_connectionid(); + const ::std::string& _internal_connectionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_connectionid(); public: // @@protoc_insertion_point(class_scope:dht.RtcOffer) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 44, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1079,48 +1143,53 @@ class RtcOffer final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RtcOffer& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr description_; ::google::protobuf::internal::ArenaStringPtr connectionid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RtcOffer_class_data_; +// ------------------------------------------------------------------- -class RtcAnswer final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RtcAnswer) */ { +class RtcAnswer final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RtcAnswer) */ { public: inline RtcAnswer() : RtcAnswer(nullptr) {} - ~RtcAnswer() override; - template - explicit PROTOBUF_CONSTEXPR RtcAnswer(::google::protobuf::internal::ConstantInitialized); + ~RtcAnswer() PROTOBUF_FINAL; - inline RtcAnswer(const RtcAnswer& from) - : RtcAnswer(nullptr, from) {} - RtcAnswer(RtcAnswer&& from) noexcept - : RtcAnswer() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RtcAnswer* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RtcAnswer)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR RtcAnswer(::google::protobuf::internal::ConstantInitialized); + inline RtcAnswer(const RtcAnswer& from) : RtcAnswer(nullptr, from) {} + inline RtcAnswer(RtcAnswer&& from) noexcept + : RtcAnswer(nullptr, ::std::move(from)) {} inline RtcAnswer& operator=(const RtcAnswer& from) { CopyFrom(from); return *this; } inline RtcAnswer& operator=(RtcAnswer&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1132,47 +1201,35 @@ class RtcAnswer final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RtcAnswer& default_instance() { - return *internal_default_instance(); - } - static inline const RtcAnswer* internal_default_instance() { - return reinterpret_cast( - &_RtcAnswer_default_instance_); + return *reinterpret_cast( + &_RtcAnswer_default_instance_); } - static constexpr int kIndexInFileMessages = - 27; - - friend void swap(RtcAnswer& a, RtcAnswer& b) { - a.Swap(&b); - } - inline void Swap(RtcAnswer* other) { + static constexpr int kIndexInFileMessages = 27; + friend void swap(RtcAnswer& a, RtcAnswer& b) { a.Swap(&b); } + inline void Swap(RtcAnswer* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RtcAnswer* other) { + void UnsafeArenaSwap(RtcAnswer* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1180,72 +1237,82 @@ class RtcAnswer final : // implements Message ---------------------------------------------- - RtcAnswer* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RtcAnswer* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RtcAnswer* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RtcAnswer"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RtcAnswer* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RtcAnswer"; } + + explicit RtcAnswer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RtcAnswer(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RtcAnswer& from); + RtcAnswer( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RtcAnswer&& from) noexcept + : RtcAnswer(arena) { + *this = ::std::move(from); } - protected: - explicit RtcAnswer(::google::protobuf::Arena* arena); - RtcAnswer(::google::protobuf::Arena* arena, const RtcAnswer& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kDescriptionFieldNumber = 1, kConnectionIdFieldNumber = 2, }; // string description = 1; void clear_description() ; - const std::string& description() const; - template + const ::std::string& description() const; + template void set_description(Arg_&& arg, Args_... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_description(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_description(); + void set_allocated_description(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description( - const std::string& value); - std::string* _internal_mutable_description(); + const ::std::string& _internal_description() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_description(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_description(); public: // string connectionId = 2; void clear_connectionid() ; - const std::string& connectionid() const; - template + const ::std::string& connectionid() const; + template void set_connectionid(Arg_&& arg, Args_... args); - std::string* mutable_connectionid(); - PROTOBUF_NODISCARD std::string* release_connectionid(); - void set_allocated_connectionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_connectionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_connectionid(); + void set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_connectionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid( - const std::string& value); - std::string* _internal_mutable_connectionid(); + const ::std::string& _internal_connectionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_connectionid(); public: // @@protoc_insertion_point(class_scope:dht.RtcAnswer) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 45, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1254,48 +1321,53 @@ class RtcAnswer final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RtcAnswer& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr description_; ::google::protobuf::internal::ArenaStringPtr connectionid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RtcAnswer_class_data_; +// ------------------------------------------------------------------- -class RouteMessageAck final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RouteMessageAck) */ { +class RouteMessageAck final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RouteMessageAck) */ { public: inline RouteMessageAck() : RouteMessageAck(nullptr) {} - ~RouteMessageAck() override; - template - explicit PROTOBUF_CONSTEXPR RouteMessageAck(::google::protobuf::internal::ConstantInitialized); + ~RouteMessageAck() PROTOBUF_FINAL; - inline RouteMessageAck(const RouteMessageAck& from) - : RouteMessageAck(nullptr, from) {} - RouteMessageAck(RouteMessageAck&& from) noexcept - : RouteMessageAck() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RouteMessageAck* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RouteMessageAck)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR RouteMessageAck(::google::protobuf::internal::ConstantInitialized); + inline RouteMessageAck(const RouteMessageAck& from) : RouteMessageAck(nullptr, from) {} + inline RouteMessageAck(RouteMessageAck&& from) noexcept + : RouteMessageAck(nullptr, ::std::move(from)) {} inline RouteMessageAck& operator=(const RouteMessageAck& from) { CopyFrom(from); return *this; } inline RouteMessageAck& operator=(RouteMessageAck&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1307,47 +1379,35 @@ class RouteMessageAck final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RouteMessageAck& default_instance() { - return *internal_default_instance(); - } - static inline const RouteMessageAck* internal_default_instance() { - return reinterpret_cast( - &_RouteMessageAck_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(RouteMessageAck& a, RouteMessageAck& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RouteMessageAck_default_instance_); } - inline void Swap(RouteMessageAck* other) { + static constexpr int kIndexInFileMessages = 18; + friend void swap(RouteMessageAck& a, RouteMessageAck& b) { a.Swap(&b); } + inline void Swap(RouteMessageAck* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RouteMessageAck* other) { + void UnsafeArenaSwap(RouteMessageAck* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1355,51 +1415,57 @@ class RouteMessageAck final : // implements Message ---------------------------------------------- - RouteMessageAck* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RouteMessageAck* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RouteMessageAck* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RouteMessageAck"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RouteMessageAck* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RouteMessageAck"; } + + explicit RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RouteMessageAck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageAck& from); + RouteMessageAck( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RouteMessageAck&& from) noexcept + : RouteMessageAck(arena) { + *this = ::std::move(from); } - protected: - explicit RouteMessageAck(::google::protobuf::Arena* arena); - RouteMessageAck(::google::protobuf::Arena* arena, const RouteMessageAck& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, kErrorFieldNumber = 2, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional .dht.RouteMessageError error = 2; @@ -1416,6 +1482,11 @@ class RouteMessageAck final : // @@protoc_insertion_point(class_scope:dht.RouteMessageAck) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 37, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1424,49 +1495,53 @@ class RouteMessageAck final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RouteMessageAck& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; int error_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RouteMessageAck_class_data_; +// ------------------------------------------------------------------- -class RecursiveOperationRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RecursiveOperationRequest) */ { +class RecursiveOperationRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RecursiveOperationRequest) */ { public: inline RecursiveOperationRequest() : RecursiveOperationRequest(nullptr) {} - ~RecursiveOperationRequest() override; - template - explicit PROTOBUF_CONSTEXPR RecursiveOperationRequest(::google::protobuf::internal::ConstantInitialized); + ~RecursiveOperationRequest() PROTOBUF_FINAL; - inline RecursiveOperationRequest(const RecursiveOperationRequest& from) - : RecursiveOperationRequest(nullptr, from) {} - RecursiveOperationRequest(RecursiveOperationRequest&& from) noexcept - : RecursiveOperationRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RecursiveOperationRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RecursiveOperationRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RecursiveOperationRequest(::google::protobuf::internal::ConstantInitialized); + + inline RecursiveOperationRequest(const RecursiveOperationRequest& from) : RecursiveOperationRequest(nullptr, from) {} + inline RecursiveOperationRequest(RecursiveOperationRequest&& from) noexcept + : RecursiveOperationRequest(nullptr, ::std::move(from)) {} inline RecursiveOperationRequest& operator=(const RecursiveOperationRequest& from) { CopyFrom(from); return *this; } inline RecursiveOperationRequest& operator=(RecursiveOperationRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1478,47 +1553,35 @@ class RecursiveOperationRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RecursiveOperationRequest& default_instance() { - return *internal_default_instance(); - } - static inline const RecursiveOperationRequest* internal_default_instance() { - return reinterpret_cast( - &_RecursiveOperationRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(RecursiveOperationRequest& a, RecursiveOperationRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RecursiveOperationRequest_default_instance_); } - inline void Swap(RecursiveOperationRequest* other) { + static constexpr int kIndexInFileMessages = 10; + friend void swap(RecursiveOperationRequest& a, RecursiveOperationRequest& b) { a.Swap(&b); } + inline void Swap(RecursiveOperationRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RecursiveOperationRequest* other) { + void UnsafeArenaSwap(RecursiveOperationRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1526,51 +1589,57 @@ class RecursiveOperationRequest final : // implements Message ---------------------------------------------- - RecursiveOperationRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RecursiveOperationRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RecursiveOperationRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RecursiveOperationRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RecursiveOperationRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RecursiveOperationRequest"; } + + explicit RecursiveOperationRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RecursiveOperationRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationRequest& from); + RecursiveOperationRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RecursiveOperationRequest&& from) noexcept + : RecursiveOperationRequest(arena) { + *this = ::std::move(from); } - protected: - explicit RecursiveOperationRequest(::google::protobuf::Arena* arena); - RecursiveOperationRequest(::google::protobuf::Arena* arena, const RecursiveOperationRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kSessionIdFieldNumber = 1, kOperationFieldNumber = 2, }; // string sessionId = 1; void clear_sessionid() ; - const std::string& sessionid() const; - template + const ::std::string& sessionid() const; + template void set_sessionid(Arg_&& arg, Args_... args); - std::string* mutable_sessionid(); - PROTOBUF_NODISCARD std::string* release_sessionid(); - void set_allocated_sessionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_sessionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_sessionid(); + void set_allocated_sessionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_sessionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_sessionid( - const std::string& value); - std::string* _internal_mutable_sessionid(); + const ::std::string& _internal_sessionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_sessionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_sessionid(); public: // .dht.RecursiveOperation operation = 2; @@ -1586,6 +1655,11 @@ class RecursiveOperationRequest final : // @@protoc_insertion_point(class_scope:dht.RecursiveOperationRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 47, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1594,48 +1668,53 @@ class RecursiveOperationRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RecursiveOperationRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr sessionid_; int operation_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationRequest_class_data_; +// ------------------------------------------------------------------- -class PingResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.PingResponse) */ { +class PingResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.PingResponse) */ { public: inline PingResponse() : PingResponse(nullptr) {} - ~PingResponse() override; - template - explicit PROTOBUF_CONSTEXPR PingResponse(::google::protobuf::internal::ConstantInitialized); + ~PingResponse() PROTOBUF_FINAL; - inline PingResponse(const PingResponse& from) - : PingResponse(nullptr, from) {} - PingResponse(PingResponse&& from) noexcept - : PingResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PingResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PingResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR PingResponse(::google::protobuf::internal::ConstantInitialized); + inline PingResponse(const PingResponse& from) : PingResponse(nullptr, from) {} + inline PingResponse(PingResponse&& from) noexcept + : PingResponse(nullptr, ::std::move(from)) {} inline PingResponse& operator=(const PingResponse& from) { CopyFrom(from); return *this; } inline PingResponse& operator=(PingResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1647,47 +1726,35 @@ class PingResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PingResponse& default_instance() { - return *internal_default_instance(); - } - static inline const PingResponse* internal_default_instance() { - return reinterpret_cast( - &_PingResponse_default_instance_); + return *reinterpret_cast( + &_PingResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(PingResponse& a, PingResponse& b) { - a.Swap(&b); - } - inline void Swap(PingResponse* other) { + static constexpr int kIndexInFileMessages = 13; + friend void swap(PingResponse& a, PingResponse& b) { a.Swap(&b); } + inline void Swap(PingResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PingResponse* other) { + void UnsafeArenaSwap(PingResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1695,55 +1762,66 @@ class PingResponse final : // implements Message ---------------------------------------------- - PingResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PingResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PingResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.PingResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PingResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.PingResponse"; } + + explicit PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PingResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingResponse& from); + PingResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PingResponse&& from) noexcept + : PingResponse(arena) { + *this = ::std::move(from); } - protected: - explicit PingResponse(::google::protobuf::Arena* arena); - PingResponse(::google::protobuf::Arena* arena, const PingResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.PingResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 34, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1752,47 +1830,52 @@ class PingResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PingResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull PingResponse_class_data_; +// ------------------------------------------------------------------- -class PingRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.PingRequest) */ { +class PingRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.PingRequest) */ { public: inline PingRequest() : PingRequest(nullptr) {} - ~PingRequest() override; - template - explicit PROTOBUF_CONSTEXPR PingRequest(::google::protobuf::internal::ConstantInitialized); + ~PingRequest() PROTOBUF_FINAL; - inline PingRequest(const PingRequest& from) - : PingRequest(nullptr, from) {} - PingRequest(PingRequest&& from) noexcept - : PingRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PingRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PingRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR PingRequest(::google::protobuf::internal::ConstantInitialized); + + inline PingRequest(const PingRequest& from) : PingRequest(nullptr, from) {} + inline PingRequest(PingRequest&& from) noexcept + : PingRequest(nullptr, ::std::move(from)) {} inline PingRequest& operator=(const PingRequest& from) { CopyFrom(from); return *this; } inline PingRequest& operator=(PingRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1804,47 +1887,35 @@ class PingRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PingRequest& default_instance() { - return *internal_default_instance(); - } - static inline const PingRequest* internal_default_instance() { - return reinterpret_cast( - &_PingRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(PingRequest& a, PingRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_PingRequest_default_instance_); } - inline void Swap(PingRequest* other) { + static constexpr int kIndexInFileMessages = 12; + friend void swap(PingRequest& a, PingRequest& b) { a.Swap(&b); } + inline void Swap(PingRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PingRequest* other) { + void UnsafeArenaSwap(PingRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1852,55 +1923,66 @@ class PingRequest final : // implements Message ---------------------------------------------- - PingRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PingRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PingRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.PingRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PingRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.PingRequest"; } + + explicit PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PingRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PingRequest& from); + PingRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PingRequest&& from) noexcept + : PingRequest(arena) { + *this = ::std::move(from); } - protected: - explicit PingRequest(::google::protobuf::Arena* arena); - PingRequest(::google::protobuf::Arena* arena, const PingRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 1, }; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.PingRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 33, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1909,47 +1991,52 @@ class PingRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PingRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class LockResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.LockResponse) */ { +extern const ::google::protobuf::internal::ClassDataFull PingRequest_class_data_; +// ------------------------------------------------------------------- + +class LockResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.LockResponse) */ { public: inline LockResponse() : LockResponse(nullptr) {} - ~LockResponse() override; - template - explicit PROTOBUF_CONSTEXPR LockResponse(::google::protobuf::internal::ConstantInitialized); + ~LockResponse() PROTOBUF_FINAL; - inline LockResponse(const LockResponse& from) - : LockResponse(nullptr, from) {} - LockResponse(LockResponse&& from) noexcept - : LockResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LockResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LockResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR LockResponse(::google::protobuf::internal::ConstantInitialized); + inline LockResponse(const LockResponse& from) : LockResponse(nullptr, from) {} + inline LockResponse(LockResponse&& from) noexcept + : LockResponse(nullptr, ::std::move(from)) {} inline LockResponse& operator=(const LockResponse& from) { CopyFrom(from); return *this; } inline LockResponse& operator=(LockResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1961,47 +2048,35 @@ class LockResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LockResponse& default_instance() { - return *internal_default_instance(); - } - static inline const LockResponse* internal_default_instance() { - return reinterpret_cast( - &_LockResponse_default_instance_); + return *reinterpret_cast( + &_LockResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 31; - - friend void swap(LockResponse& a, LockResponse& b) { - a.Swap(&b); - } - inline void Swap(LockResponse* other) { + static constexpr int kIndexInFileMessages = 31; + friend void swap(LockResponse& a, LockResponse& b) { a.Swap(&b); } + inline void Swap(LockResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LockResponse* other) { + void UnsafeArenaSwap(LockResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2009,33 +2084,40 @@ class LockResponse final : // implements Message ---------------------------------------------- - LockResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LockResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(LockResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.LockResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(LockResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.LockResponse"; } + + explicit LockResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LockResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockResponse& from); + LockResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LockResponse&& from) noexcept + : LockResponse(arena) { + *this = ::std::move(from); } - protected: - explicit LockResponse(::google::protobuf::Arena* arena); - LockResponse(::google::protobuf::Arena* arena, const LockResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kAcceptedFieldNumber = 1, }; @@ -2052,6 +2134,11 @@ class LockResponse final : // @@protoc_insertion_point(class_scope:dht.LockResponse) 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; @@ -2060,47 +2147,52 @@ class LockResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const LockResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; bool accepted_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull LockResponse_class_data_; +// ------------------------------------------------------------------- -class LockRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.LockRequest) */ { +class LockRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.LockRequest) */ { public: inline LockRequest() : LockRequest(nullptr) {} - ~LockRequest() override; - template - explicit PROTOBUF_CONSTEXPR LockRequest(::google::protobuf::internal::ConstantInitialized); + ~LockRequest() PROTOBUF_FINAL; - inline LockRequest(const LockRequest& from) - : LockRequest(nullptr, from) {} - LockRequest(LockRequest&& from) noexcept - : LockRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LockRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LockRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR LockRequest(::google::protobuf::internal::ConstantInitialized); + + inline LockRequest(const LockRequest& from) : LockRequest(nullptr, from) {} + inline LockRequest(LockRequest&& from) noexcept + : LockRequest(nullptr, ::std::move(from)) {} inline LockRequest& operator=(const LockRequest& from) { CopyFrom(from); return *this; } inline LockRequest& operator=(LockRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2112,47 +2204,35 @@ class LockRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LockRequest& default_instance() { - return *internal_default_instance(); - } - static inline const LockRequest* internal_default_instance() { - return reinterpret_cast( - &_LockRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 29; - - friend void swap(LockRequest& a, LockRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_LockRequest_default_instance_); } - inline void Swap(LockRequest* other) { + static constexpr int kIndexInFileMessages = 29; + friend void swap(LockRequest& a, LockRequest& b) { a.Swap(&b); } + inline void Swap(LockRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LockRequest* other) { + void UnsafeArenaSwap(LockRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2160,55 +2240,66 @@ class LockRequest final : // implements Message ---------------------------------------------- - LockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LockRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(LockRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.LockRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(LockRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.LockRequest"; } + + explicit LockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LockRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LockRequest& from); + LockRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LockRequest&& from) noexcept + : LockRequest(arena) { + *this = ::std::move(from); } - protected: - explicit LockRequest(::google::protobuf::Arena* arena); - LockRequest(::google::protobuf::Arena* arena, const LockRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kLockIdFieldNumber = 1, }; // string lockId = 1; void clear_lockid() ; - const std::string& lockid() const; - template + const ::std::string& lockid() const; + template void set_lockid(Arg_&& arg, Args_... args); - std::string* mutable_lockid(); - PROTOBUF_NODISCARD std::string* release_lockid(); - void set_allocated_lockid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_lockid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_lockid(); + void set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_lockid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_lockid( - const std::string& value); - std::string* _internal_mutable_lockid(); + const ::std::string& _internal_lockid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_lockid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_lockid(); public: // @@protoc_insertion_point(class_scope:dht.LockRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 0, 30, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2217,46 +2308,51 @@ class LockRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const LockRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr lockid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class LeaveNotice final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:dht.LeaveNotice) */ { +extern const ::google::protobuf::internal::ClassDataFull LockRequest_class_data_; +// ------------------------------------------------------------------- + +class LeaveNotice final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:dht.LeaveNotice) */ { public: inline LeaveNotice() : LeaveNotice(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR LeaveNotice(::google::protobuf::internal::ConstantInitialized); - inline LeaveNotice(const LeaveNotice& from) - : LeaveNotice(nullptr, from) {} - LeaveNotice(LeaveNotice&& from) noexcept - : LeaveNotice() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LeaveNotice* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LeaveNotice)); } +#endif + template + explicit PROTOBUF_CONSTEXPR LeaveNotice(::google::protobuf::internal::ConstantInitialized); + + inline LeaveNotice(const LeaveNotice& from) : LeaveNotice(nullptr, from) {} + inline LeaveNotice(LeaveNotice&& from) noexcept + : LeaveNotice(nullptr, ::std::move(from)) {} inline LeaveNotice& operator=(const LeaveNotice& from) { CopyFrom(from); return *this; } inline LeaveNotice& operator=(LeaveNotice&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2268,47 +2364,35 @@ class LeaveNotice final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LeaveNotice& default_instance() { - return *internal_default_instance(); - } - static inline const LeaveNotice* internal_default_instance() { - return reinterpret_cast( - &_LeaveNotice_default_instance_); + return *reinterpret_cast( + &_LeaveNotice_default_instance_); } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(LeaveNotice& a, LeaveNotice& b) { - a.Swap(&b); - } - inline void Swap(LeaveNotice* other) { + static constexpr int kIndexInFileMessages = 14; + friend void swap(LeaveNotice& a, LeaveNotice& b) { a.Swap(&b); } + inline void Swap(LeaveNotice* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LeaveNotice* other) { + void UnsafeArenaSwap(LeaveNotice* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2316,29 +2400,42 @@ class LeaveNotice final : // implements Message ---------------------------------------------- - LeaveNotice* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LeaveNotice* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.LeaveNotice"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.LeaveNotice"; } + + explicit LeaveNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LeaveNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LeaveNotice& from); + LeaveNotice( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LeaveNotice&& from) noexcept + : LeaveNotice(arena) { + *this = ::std::move(from); } - protected: - explicit LeaveNotice(::google::protobuf::Arena* arena); - LeaveNotice(::google::protobuf::Arena* arena, const LeaveNotice& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dht.LeaveNotice) 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; @@ -2346,45 +2443,38 @@ class LeaveNotice final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class IceCandidate final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.IceCandidate) */ { +extern const ::google::protobuf::internal::ClassDataFull LeaveNotice_class_data_; +// ------------------------------------------------------------------- + +class IceCandidate final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.IceCandidate) */ { public: inline IceCandidate() : IceCandidate(nullptr) {} - ~IceCandidate() override; - template - explicit PROTOBUF_CONSTEXPR IceCandidate(::google::protobuf::internal::ConstantInitialized); + ~IceCandidate() PROTOBUF_FINAL; - inline IceCandidate(const IceCandidate& from) - : IceCandidate(nullptr, from) {} - IceCandidate(IceCandidate&& from) noexcept - : IceCandidate() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IceCandidate* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IceCandidate)); } +#endif + template + explicit PROTOBUF_CONSTEXPR IceCandidate(::google::protobuf::internal::ConstantInitialized); + + inline IceCandidate(const IceCandidate& from) : IceCandidate(nullptr, from) {} + inline IceCandidate(IceCandidate&& from) noexcept + : IceCandidate(nullptr, ::std::move(from)) {} inline IceCandidate& operator=(const IceCandidate& from) { CopyFrom(from); return *this; } inline IceCandidate& operator=(IceCandidate&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2396,47 +2486,35 @@ class IceCandidate final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const IceCandidate& default_instance() { - return *internal_default_instance(); - } - static inline const IceCandidate* internal_default_instance() { - return reinterpret_cast( - &_IceCandidate_default_instance_); + return *reinterpret_cast( + &_IceCandidate_default_instance_); } - static constexpr int kIndexInFileMessages = - 28; - - friend void swap(IceCandidate& a, IceCandidate& b) { - a.Swap(&b); - } - inline void Swap(IceCandidate* other) { + static constexpr int kIndexInFileMessages = 28; + friend void swap(IceCandidate& a, IceCandidate& b) { a.Swap(&b); } + inline void Swap(IceCandidate* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(IceCandidate* other) { + void UnsafeArenaSwap(IceCandidate* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2444,33 +2522,40 @@ class IceCandidate final : // implements Message ---------------------------------------------- - IceCandidate* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + IceCandidate* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(IceCandidate* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.IceCandidate"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(IceCandidate* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.IceCandidate"; } + + explicit IceCandidate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + IceCandidate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IceCandidate& from); + IceCandidate( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, IceCandidate&& from) noexcept + : IceCandidate(arena) { + *this = ::std::move(from); } - protected: - explicit IceCandidate(::google::protobuf::Arena* arena); - IceCandidate(::google::protobuf::Arena* arena, const IceCandidate& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kCandidateFieldNumber = 1, kMidFieldNumber = 2, @@ -2478,55 +2563,57 @@ class IceCandidate final : }; // string candidate = 1; void clear_candidate() ; - const std::string& candidate() const; - template + const ::std::string& candidate() const; + template void set_candidate(Arg_&& arg, Args_... args); - std::string* mutable_candidate(); - PROTOBUF_NODISCARD std::string* release_candidate(); - void set_allocated_candidate(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_candidate(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_candidate(); + void set_allocated_candidate(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_candidate() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_candidate( - const std::string& value); - std::string* _internal_mutable_candidate(); + const ::std::string& _internal_candidate() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_candidate(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_candidate(); public: // string mid = 2; void clear_mid() ; - const std::string& mid() const; - template + const ::std::string& mid() const; + template void set_mid(Arg_&& arg, Args_... args); - std::string* mutable_mid(); - PROTOBUF_NODISCARD std::string* release_mid(); - void set_allocated_mid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_mid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_mid(); + void set_allocated_mid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_mid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mid( - const std::string& value); - std::string* _internal_mutable_mid(); + const ::std::string& _internal_mid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_mid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_mid(); public: // string connectionId = 3; void clear_connectionid() ; - const std::string& connectionid() const; - template + const ::std::string& connectionid() const; + template void set_connectionid(Arg_&& arg, Args_... args); - std::string* mutable_connectionid(); - PROTOBUF_NODISCARD std::string* release_connectionid(); - void set_allocated_connectionid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_connectionid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_connectionid(); + void set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_connectionid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid( - const std::string& value); - std::string* _internal_mutable_connectionid(); + const ::std::string& _internal_connectionid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_connectionid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_connectionid(); public: // @@protoc_insertion_point(class_scope:dht.IceCandidate) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 0, 49, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2535,49 +2622,54 @@ class IceCandidate final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const IceCandidate& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr candidate_; ::google::protobuf::internal::ArenaStringPtr mid_; ::google::protobuf::internal::ArenaStringPtr connectionid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull IceCandidate_class_data_; +// ------------------------------------------------------------------- -class ExternalFetchDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataRequest) */ { +class ExternalFetchDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataRequest) */ { public: inline ExternalFetchDataRequest() : ExternalFetchDataRequest(nullptr) {} - ~ExternalFetchDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR ExternalFetchDataRequest(::google::protobuf::internal::ConstantInitialized); + ~ExternalFetchDataRequest() PROTOBUF_FINAL; - inline ExternalFetchDataRequest(const ExternalFetchDataRequest& from) - : ExternalFetchDataRequest(nullptr, from) {} - ExternalFetchDataRequest(ExternalFetchDataRequest&& from) noexcept - : ExternalFetchDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalFetchDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalFetchDataRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalFetchDataRequest(::google::protobuf::internal::ConstantInitialized); + inline ExternalFetchDataRequest(const ExternalFetchDataRequest& from) : ExternalFetchDataRequest(nullptr, from) {} + inline ExternalFetchDataRequest(ExternalFetchDataRequest&& from) noexcept + : ExternalFetchDataRequest(nullptr, ::std::move(from)) {} inline ExternalFetchDataRequest& operator=(const ExternalFetchDataRequest& from) { CopyFrom(from); return *this; } inline ExternalFetchDataRequest& operator=(ExternalFetchDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2589,47 +2681,35 @@ class ExternalFetchDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalFetchDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalFetchDataRequest* internal_default_instance() { - return reinterpret_cast( - &_ExternalFetchDataRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 33; - - friend void swap(ExternalFetchDataRequest& a, ExternalFetchDataRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ExternalFetchDataRequest_default_instance_); } - inline void Swap(ExternalFetchDataRequest* other) { + static constexpr int kIndexInFileMessages = 33; + friend void swap(ExternalFetchDataRequest& a, ExternalFetchDataRequest& b) { a.Swap(&b); } + inline void Swap(ExternalFetchDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalFetchDataRequest* other) { + void UnsafeArenaSwap(ExternalFetchDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2637,55 +2717,66 @@ class ExternalFetchDataRequest final : // implements Message ---------------------------------------------- - ExternalFetchDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalFetchDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalFetchDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalFetchDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalFetchDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalFetchDataRequest"; } + + explicit ExternalFetchDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalFetchDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataRequest& from); + ExternalFetchDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalFetchDataRequest&& from) noexcept + : ExternalFetchDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalFetchDataRequest(::google::protobuf::Arena* arena); - ExternalFetchDataRequest(::google::protobuf::Arena* arena, const ExternalFetchDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // @@protoc_insertion_point(class_scope:dht.ExternalFetchDataRequest) 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; @@ -2694,47 +2785,52 @@ class ExternalFetchDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalFetchDataRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class DisconnectNotice final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.DisconnectNotice) */ { +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataRequest_class_data_; +// ------------------------------------------------------------------- + +class DisconnectNotice final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.DisconnectNotice) */ { public: inline DisconnectNotice() : DisconnectNotice(nullptr) {} - ~DisconnectNotice() override; - template - explicit PROTOBUF_CONSTEXPR DisconnectNotice(::google::protobuf::internal::ConstantInitialized); + ~DisconnectNotice() PROTOBUF_FINAL; - inline DisconnectNotice(const DisconnectNotice& from) - : DisconnectNotice(nullptr, from) {} - DisconnectNotice(DisconnectNotice&& from) noexcept - : DisconnectNotice() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DisconnectNotice* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DisconnectNotice)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR DisconnectNotice(::google::protobuf::internal::ConstantInitialized); + inline DisconnectNotice(const DisconnectNotice& from) : DisconnectNotice(nullptr, from) {} + inline DisconnectNotice(DisconnectNotice&& from) noexcept + : DisconnectNotice(nullptr, ::std::move(from)) {} inline DisconnectNotice& operator=(const DisconnectNotice& from) { CopyFrom(from); return *this; } inline DisconnectNotice& operator=(DisconnectNotice&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2746,47 +2842,35 @@ class DisconnectNotice final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const DisconnectNotice& default_instance() { - return *internal_default_instance(); - } - static inline const DisconnectNotice* internal_default_instance() { - return reinterpret_cast( - &_DisconnectNotice_default_instance_); + return *reinterpret_cast( + &_DisconnectNotice_default_instance_); } - static constexpr int kIndexInFileMessages = - 32; - - friend void swap(DisconnectNotice& a, DisconnectNotice& b) { - a.Swap(&b); - } - inline void Swap(DisconnectNotice* other) { + static constexpr int kIndexInFileMessages = 32; + friend void swap(DisconnectNotice& a, DisconnectNotice& b) { a.Swap(&b); } + inline void Swap(DisconnectNotice* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(DisconnectNotice* other) { + void UnsafeArenaSwap(DisconnectNotice* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2794,33 +2878,40 @@ class DisconnectNotice final : // implements Message ---------------------------------------------- - DisconnectNotice* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + DisconnectNotice* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(DisconnectNotice* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.DisconnectNotice"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(DisconnectNotice* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.DisconnectNotice"; } + + explicit DisconnectNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + DisconnectNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DisconnectNotice& from); + DisconnectNotice( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DisconnectNotice&& from) noexcept + : DisconnectNotice(arena) { + *this = ::std::move(from); } - protected: - explicit DisconnectNotice(::google::protobuf::Arena* arena); - DisconnectNotice(::google::protobuf::Arena* arena, const DisconnectNotice& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kDisconnectModeFieldNumber = 1, }; @@ -2837,6 +2928,11 @@ class DisconnectNotice final : // @@protoc_insertion_point(class_scope:dht.DisconnectNotice) 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; @@ -2845,47 +2941,52 @@ class DisconnectNotice final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const DisconnectNotice& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; int disconnectmode_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull DisconnectNotice_class_data_; +// ------------------------------------------------------------------- -class ConnectivityRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ConnectivityRequest) */ { +class ConnectivityRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ConnectivityRequest) */ { public: inline ConnectivityRequest() : ConnectivityRequest(nullptr) {} - ~ConnectivityRequest() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityRequest(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityRequest() PROTOBUF_FINAL; - inline ConnectivityRequest(const ConnectivityRequest& from) - : ConnectivityRequest(nullptr, from) {} - ConnectivityRequest(ConnectivityRequest&& from) noexcept - : ConnectivityRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConnectivityRequest(::google::protobuf::internal::ConstantInitialized); + inline ConnectivityRequest(const ConnectivityRequest& from) : ConnectivityRequest(nullptr, from) {} + inline ConnectivityRequest(ConnectivityRequest&& from) noexcept + : ConnectivityRequest(nullptr, ::std::move(from)) {} inline ConnectivityRequest& operator=(const ConnectivityRequest& from) { CopyFrom(from); return *this; } inline ConnectivityRequest& operator=(ConnectivityRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2897,47 +2998,35 @@ class ConnectivityRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ConnectivityRequest* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(ConnectivityRequest& a, ConnectivityRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ConnectivityRequest_default_instance_); } - inline void Swap(ConnectivityRequest* other) { + static constexpr int kIndexInFileMessages = 19; + friend void swap(ConnectivityRequest& a, ConnectivityRequest& b) { a.Swap(&b); } + inline void Swap(ConnectivityRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityRequest* other) { + void UnsafeArenaSwap(ConnectivityRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2945,33 +3034,40 @@ class ConnectivityRequest final : // implements Message ---------------------------------------------- - ConnectivityRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ConnectivityRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ConnectivityRequest"; } + + explicit ConnectivityRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityRequest& from); + ConnectivityRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityRequest&& from) noexcept + : ConnectivityRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityRequest(::google::protobuf::Arena* arena); - ConnectivityRequest(::google::protobuf::Arena* arena, const ConnectivityRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kHostFieldNumber = 3, kPortFieldNumber = 1, @@ -2981,18 +3077,17 @@ class ConnectivityRequest final : // optional string host = 3; bool has_host() const; void clear_host() ; - const std::string& host() const; - template + const ::std::string& host() const; + template void set_host(Arg_&& arg, Args_... args); - std::string* mutable_host(); - PROTOBUF_NODISCARD std::string* release_host(); - void set_allocated_host(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_host(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host(); + void set_allocated_host(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_host() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( - const std::string& value); - std::string* _internal_mutable_host(); + const ::std::string& _internal_host() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_host(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_host(); public: // uint32 port = 1; @@ -3028,6 +3123,11 @@ class ConnectivityRequest final : // @@protoc_insertion_point(class_scope:dht.ConnectivityRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 0, 36, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3036,15 +3136,16 @@ class ConnectivityRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr host_; ::uint32_t port_; bool tls_; @@ -3053,34 +3154,37 @@ class ConnectivityRequest final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class ConnectivityMethod final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ConnectivityMethod) */ { +extern const ::google::protobuf::internal::ClassDataFull ConnectivityRequest_class_data_; +// ------------------------------------------------------------------- + +class ConnectivityMethod final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ConnectivityMethod) */ { public: inline ConnectivityMethod() : ConnectivityMethod(nullptr) {} - ~ConnectivityMethod() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityMethod(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityMethod() PROTOBUF_FINAL; - inline ConnectivityMethod(const ConnectivityMethod& from) - : ConnectivityMethod(nullptr, from) {} - ConnectivityMethod(ConnectivityMethod&& from) noexcept - : ConnectivityMethod() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityMethod* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityMethod)); } +#endif + template + explicit PROTOBUF_CONSTEXPR ConnectivityMethod(::google::protobuf::internal::ConstantInitialized); + + inline ConnectivityMethod(const ConnectivityMethod& from) : ConnectivityMethod(nullptr, from) {} + inline ConnectivityMethod(ConnectivityMethod&& from) noexcept + : ConnectivityMethod(nullptr, ::std::move(from)) {} inline ConnectivityMethod& operator=(const ConnectivityMethod& from) { CopyFrom(from); return *this; } inline ConnectivityMethod& operator=(ConnectivityMethod&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3092,47 +3196,35 @@ class ConnectivityMethod final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityMethod& default_instance() { - return *internal_default_instance(); - } - static inline const ConnectivityMethod* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityMethod_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(ConnectivityMethod& a, ConnectivityMethod& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ConnectivityMethod_default_instance_); } - inline void Swap(ConnectivityMethod* other) { + static constexpr int kIndexInFileMessages = 16; + friend void swap(ConnectivityMethod& a, ConnectivityMethod& b) { a.Swap(&b); } + inline void Swap(ConnectivityMethod* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityMethod* other) { + void UnsafeArenaSwap(ConnectivityMethod* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3140,33 +3232,40 @@ class ConnectivityMethod final : // implements Message ---------------------------------------------- - ConnectivityMethod* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityMethod* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityMethod* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ConnectivityMethod"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityMethod* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ConnectivityMethod"; } + + explicit ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityMethod(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityMethod& from); + ConnectivityMethod( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityMethod&& from) noexcept + : ConnectivityMethod(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityMethod(::google::protobuf::Arena* arena); - ConnectivityMethod(::google::protobuf::Arena* arena, const ConnectivityMethod& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kHostFieldNumber = 2, kPortFieldNumber = 1, @@ -3174,18 +3273,17 @@ class ConnectivityMethod final : }; // string host = 2; void clear_host() ; - const std::string& host() const; - template + const ::std::string& host() const; + template void set_host(Arg_&& arg, Args_... args); - std::string* mutable_host(); - PROTOBUF_NODISCARD std::string* release_host(); - void set_allocated_host(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_host(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host(); + void set_allocated_host(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_host() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( - const std::string& value); - std::string* _internal_mutable_host(); + const ::std::string& _internal_host() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_host(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_host(); public: // uint32 port = 1; @@ -3211,6 +3309,11 @@ class ConnectivityMethod final : // @@protoc_insertion_point(class_scope:dht.ConnectivityMethod) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 0, 35, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3219,49 +3322,54 @@ class ConnectivityMethod final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityMethod& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr host_; ::uint32_t port_; bool tls_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class ClosestRingPeersRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull ConnectivityMethod_class_data_; +// ------------------------------------------------------------------- + +class ClosestRingPeersRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersRequest) */ { public: inline ClosestRingPeersRequest() : ClosestRingPeersRequest(nullptr) {} - ~ClosestRingPeersRequest() override; - template - explicit PROTOBUF_CONSTEXPR ClosestRingPeersRequest(::google::protobuf::internal::ConstantInitialized); + ~ClosestRingPeersRequest() PROTOBUF_FINAL; - inline ClosestRingPeersRequest(const ClosestRingPeersRequest& from) - : ClosestRingPeersRequest(nullptr, from) {} - ClosestRingPeersRequest(ClosestRingPeersRequest&& from) noexcept - : ClosestRingPeersRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestRingPeersRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestRingPeersRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestRingPeersRequest(::google::protobuf::internal::ConstantInitialized); + inline ClosestRingPeersRequest(const ClosestRingPeersRequest& from) : ClosestRingPeersRequest(nullptr, from) {} + inline ClosestRingPeersRequest(ClosestRingPeersRequest&& from) noexcept + : ClosestRingPeersRequest(nullptr, ::std::move(from)) {} inline ClosestRingPeersRequest& operator=(const ClosestRingPeersRequest& from) { CopyFrom(from); return *this; } inline ClosestRingPeersRequest& operator=(ClosestRingPeersRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3273,47 +3381,35 @@ class ClosestRingPeersRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestRingPeersRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestRingPeersRequest* internal_default_instance() { - return reinterpret_cast( - &_ClosestRingPeersRequest_default_instance_); + return *reinterpret_cast( + &_ClosestRingPeersRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(ClosestRingPeersRequest& a, ClosestRingPeersRequest& b) { - a.Swap(&b); - } - inline void Swap(ClosestRingPeersRequest* other) { + static constexpr int kIndexInFileMessages = 8; + friend void swap(ClosestRingPeersRequest& a, ClosestRingPeersRequest& b) { a.Swap(&b); } + inline void Swap(ClosestRingPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestRingPeersRequest* other) { + void UnsafeArenaSwap(ClosestRingPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3321,72 +3417,82 @@ class ClosestRingPeersRequest final : // implements Message ---------------------------------------------- - ClosestRingPeersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestRingPeersRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestRingPeersRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestRingPeersRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestRingPeersRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestRingPeersRequest"; } + + explicit ClosestRingPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestRingPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersRequest& from); + ClosestRingPeersRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestRingPeersRequest&& from) noexcept + : ClosestRingPeersRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestRingPeersRequest(::google::protobuf::Arena* arena); - ClosestRingPeersRequest(::google::protobuf::Arena* arena, const ClosestRingPeersRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRingIdFieldNumber = 1, kRequestIdFieldNumber = 2, }; // bytes ringId = 1; void clear_ringid() ; - const std::string& ringid() const; - template + const ::std::string& ringid() const; + template void set_ringid(Arg_&& arg, Args_... args); - std::string* mutable_ringid(); - PROTOBUF_NODISCARD std::string* release_ringid(); - void set_allocated_ringid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_ringid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_ringid(); + void set_allocated_ringid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_ringid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ringid( - const std::string& value); - std::string* _internal_mutable_ringid(); + const ::std::string& _internal_ringid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_ringid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_ringid(); public: // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestRingPeersRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 45, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3395,48 +3501,53 @@ class ClosestRingPeersRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestRingPeersRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr ringid_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersRequest_class_data_; +// ------------------------------------------------------------------- -class ClosestPeersRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestPeersRequest) */ { +class ClosestPeersRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestPeersRequest) */ { public: inline ClosestPeersRequest() : ClosestPeersRequest(nullptr) {} - ~ClosestPeersRequest() override; - template - explicit PROTOBUF_CONSTEXPR ClosestPeersRequest(::google::protobuf::internal::ConstantInitialized); + ~ClosestPeersRequest() PROTOBUF_FINAL; - inline ClosestPeersRequest(const ClosestPeersRequest& from) - : ClosestPeersRequest(nullptr, from) {} - ClosestPeersRequest(ClosestPeersRequest&& from) noexcept - : ClosestPeersRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestPeersRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestPeersRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestPeersRequest(::google::protobuf::internal::ConstantInitialized); + inline ClosestPeersRequest(const ClosestPeersRequest& from) : ClosestPeersRequest(nullptr, from) {} + inline ClosestPeersRequest(ClosestPeersRequest&& from) noexcept + : ClosestPeersRequest(nullptr, ::std::move(from)) {} inline ClosestPeersRequest& operator=(const ClosestPeersRequest& from) { CopyFrom(from); return *this; } inline ClosestPeersRequest& operator=(ClosestPeersRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3448,47 +3559,35 @@ class ClosestPeersRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestPeersRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestPeersRequest* internal_default_instance() { - return reinterpret_cast( - &_ClosestPeersRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(ClosestPeersRequest& a, ClosestPeersRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ClosestPeersRequest_default_instance_); } - inline void Swap(ClosestPeersRequest* other) { + static constexpr int kIndexInFileMessages = 6; + friend void swap(ClosestPeersRequest& a, ClosestPeersRequest& b) { a.Swap(&b); } + inline void Swap(ClosestPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestPeersRequest* other) { + void UnsafeArenaSwap(ClosestPeersRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3496,72 +3595,82 @@ class ClosestPeersRequest final : // implements Message ---------------------------------------------- - ClosestPeersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestPeersRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestPeersRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestPeersRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestPeersRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestPeersRequest"; } + + explicit ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestPeersRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersRequest& from); + ClosestPeersRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestPeersRequest&& from) noexcept + : ClosestPeersRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestPeersRequest(::google::protobuf::Arena* arena); - ClosestPeersRequest(::google::protobuf::Arena* arena, const ClosestPeersRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNodeIdFieldNumber = 1, kRequestIdFieldNumber = 2, }; // bytes nodeId = 1; void clear_nodeid() ; - const std::string& nodeid() const; - template + const ::std::string& nodeid() const; + template void set_nodeid(Arg_&& arg, Args_... args); - std::string* mutable_nodeid(); - PROTOBUF_NODISCARD std::string* release_nodeid(); - void set_allocated_nodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nodeid(); + void set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid( - const std::string& value); - std::string* _internal_mutable_nodeid(); + const ::std::string& _internal_nodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nodeid(); public: // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestPeersRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 41, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3570,48 +3679,53 @@ class ClosestPeersRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestPeersRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr nodeid_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class StoreDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.StoreDataRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersRequest_class_data_; +// ------------------------------------------------------------------- + +class StoreDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.StoreDataRequest) */ { public: inline StoreDataRequest() : StoreDataRequest(nullptr) {} - ~StoreDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR StoreDataRequest(::google::protobuf::internal::ConstantInitialized); + ~StoreDataRequest() PROTOBUF_FINAL; - inline StoreDataRequest(const StoreDataRequest& from) - : StoreDataRequest(nullptr, from) {} - StoreDataRequest(StoreDataRequest&& from) noexcept - : StoreDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StoreDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StoreDataRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR StoreDataRequest(::google::protobuf::internal::ConstantInitialized); + + inline StoreDataRequest(const StoreDataRequest& from) : StoreDataRequest(nullptr, from) {} + inline StoreDataRequest(StoreDataRequest&& from) noexcept + : StoreDataRequest(nullptr, ::std::move(from)) {} inline StoreDataRequest& operator=(const StoreDataRequest& from) { CopyFrom(from); return *this; } inline StoreDataRequest& operator=(StoreDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3623,47 +3737,35 @@ class StoreDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StoreDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const StoreDataRequest* internal_default_instance() { - return reinterpret_cast( - &_StoreDataRequest_default_instance_); + return *reinterpret_cast( + &_StoreDataRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(StoreDataRequest& a, StoreDataRequest& b) { - a.Swap(&b); - } - inline void Swap(StoreDataRequest* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(StoreDataRequest& a, StoreDataRequest& b) { a.Swap(&b); } + inline void Swap(StoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StoreDataRequest* other) { + void UnsafeArenaSwap(StoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3671,33 +3773,40 @@ class StoreDataRequest final : // implements Message ---------------------------------------------- - StoreDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StoreDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(StoreDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.StoreDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(StoreDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.StoreDataRequest"; } + + explicit StoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StoreDataRequest& from); + StoreDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StoreDataRequest&& from) noexcept + : StoreDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit StoreDataRequest(::google::protobuf::Arena* arena); - StoreDataRequest(::google::protobuf::Arena* arena, const StoreDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, kCreatorFieldNumber = 3, @@ -3707,64 +3816,62 @@ class StoreDataRequest final : }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // bytes creator = 3; void clear_creator() ; - const std::string& creator() const; - template + const ::std::string& creator() const; + template void set_creator(Arg_&& arg, Args_... args); - std::string* mutable_creator(); - PROTOBUF_NODISCARD std::string* release_creator(); - void set_allocated_creator(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_creator(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_creator(); + void set_allocated_creator(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_creator() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_creator( - const std::string& value); - std::string* _internal_mutable_creator(); + const ::std::string& _internal_creator() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_creator(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_creator(); public: // .google.protobuf.Any data = 2; bool has_data() const; void clear_data() ; const ::google::protobuf::Any& data() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); - ::google::protobuf::Any* mutable_data(); - void set_allocated_data(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_data(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_data(); + void set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_data(); private: const ::google::protobuf::Any& _internal_data() const; - ::google::protobuf::Any* _internal_mutable_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_data(); public: // .google.protobuf.Timestamp createdAt = 4; bool has_createdat() const; void clear_createdat() ; const ::google::protobuf::Timestamp& createdat() const; - PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_createdat(); - ::google::protobuf::Timestamp* mutable_createdat(); - void set_allocated_createdat(::google::protobuf::Timestamp* value); - void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value); - ::google::protobuf::Timestamp* unsafe_arena_release_createdat(); + [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_createdat(); + void set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_createdat(); private: const ::google::protobuf::Timestamp& _internal_createdat() const; - ::google::protobuf::Timestamp* _internal_mutable_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_createdat(); public: // uint32 ttl = 5; @@ -3780,6 +3887,11 @@ class StoreDataRequest final : // @@protoc_insertion_point(class_scope:dht.StoreDataRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 2, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3788,52 +3900,56 @@ class StoreDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const StoreDataRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; ::google::protobuf::internal::ArenaStringPtr creator_; - ::google::protobuf::Any* data_; - ::google::protobuf::Timestamp* createdat_; + ::google::protobuf::Any* PROTOBUF_NULLABLE data_; + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE createdat_; ::uint32_t ttl_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StoreDataRequest_class_data_; +// ------------------------------------------------------------------- -class PeerDescriptor final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.PeerDescriptor) */ { +class PeerDescriptor final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.PeerDescriptor) */ { public: inline PeerDescriptor() : PeerDescriptor(nullptr) {} - ~PeerDescriptor() override; - template - explicit PROTOBUF_CONSTEXPR PeerDescriptor(::google::protobuf::internal::ConstantInitialized); + ~PeerDescriptor() PROTOBUF_FINAL; - inline PeerDescriptor(const PeerDescriptor& from) - : PeerDescriptor(nullptr, from) {} - PeerDescriptor(PeerDescriptor&& from) noexcept - : PeerDescriptor() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PeerDescriptor* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PeerDescriptor)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR PeerDescriptor(::google::protobuf::internal::ConstantInitialized); + inline PeerDescriptor(const PeerDescriptor& from) : PeerDescriptor(nullptr, from) {} + inline PeerDescriptor(PeerDescriptor&& from) noexcept + : PeerDescriptor(nullptr, ::std::move(from)) {} inline PeerDescriptor& operator=(const PeerDescriptor& from) { CopyFrom(from); return *this; } inline PeerDescriptor& operator=(PeerDescriptor&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3845,47 +3961,35 @@ class PeerDescriptor final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerDescriptor& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_PeerDescriptor_default_instance_); } - static inline const PeerDescriptor* internal_default_instance() { - return reinterpret_cast( - &_PeerDescriptor_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(PeerDescriptor& a, PeerDescriptor& b) { - a.Swap(&b); - } - inline void Swap(PeerDescriptor* other) { + static constexpr int kIndexInFileMessages = 15; + friend void swap(PeerDescriptor& a, PeerDescriptor& b) { a.Swap(&b); } + inline void Swap(PeerDescriptor* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PeerDescriptor* other) { + void UnsafeArenaSwap(PeerDescriptor* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3893,33 +3997,40 @@ class PeerDescriptor final : // implements Message ---------------------------------------------- - PeerDescriptor* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + PeerDescriptor* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(PeerDescriptor* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.PeerDescriptor"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PeerDescriptor* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.PeerDescriptor"; } + + explicit PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PeerDescriptor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PeerDescriptor& from); + PeerDescriptor( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PeerDescriptor&& from) noexcept + : PeerDescriptor(arena) { + *this = ::std::move(from); } - protected: - explicit PeerDescriptor(::google::protobuf::Arena* arena); - PeerDescriptor(::google::protobuf::Arena* arena, const PeerDescriptor& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNodeIdFieldNumber = 1, kPublicKeyFieldNumber = 8, @@ -3933,97 +4044,94 @@ class PeerDescriptor final : }; // bytes nodeId = 1; void clear_nodeid() ; - const std::string& nodeid() const; - template + const ::std::string& nodeid() const; + template void set_nodeid(Arg_&& arg, Args_... args); - std::string* mutable_nodeid(); - PROTOBUF_NODISCARD std::string* release_nodeid(); - void set_allocated_nodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nodeid(); + void set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid( - const std::string& value); - std::string* _internal_mutable_nodeid(); + const ::std::string& _internal_nodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nodeid(); public: // optional bytes publicKey = 8; bool has_publickey() const; void clear_publickey() ; - const std::string& publickey() const; - template + const ::std::string& publickey() const; + template void set_publickey(Arg_&& arg, Args_... args); - std::string* mutable_publickey(); - PROTOBUF_NODISCARD std::string* release_publickey(); - void set_allocated_publickey(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_publickey(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_publickey(); + void set_allocated_publickey(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_publickey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey( - const std::string& value); - std::string* _internal_mutable_publickey(); + const ::std::string& _internal_publickey() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_publickey(); public: // optional bytes signature = 9; bool has_signature() const; void clear_signature() ; - const std::string& signature() const; - template + const ::std::string& signature() const; + template void set_signature(Arg_&& arg, Args_... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_signature(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_signature(); + void set_allocated_signature(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature( - const std::string& value); - std::string* _internal_mutable_signature(); + const ::std::string& _internal_signature() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_signature(); public: // .dht.ConnectivityMethod udp = 3; bool has_udp() const; void clear_udp() ; const ::dht::ConnectivityMethod& udp() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_udp(); - ::dht::ConnectivityMethod* mutable_udp(); - void set_allocated_udp(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_udp(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_udp(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_udp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_udp(); + void set_allocated_udp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_udp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_udp(); private: const ::dht::ConnectivityMethod& _internal_udp() const; - ::dht::ConnectivityMethod* _internal_mutable_udp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_udp(); public: // .dht.ConnectivityMethod tcp = 4; bool has_tcp() const; void clear_tcp() ; const ::dht::ConnectivityMethod& tcp() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_tcp(); - ::dht::ConnectivityMethod* mutable_tcp(); - void set_allocated_tcp(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_tcp(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_tcp(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_tcp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_tcp(); + void set_allocated_tcp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_tcp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_tcp(); private: const ::dht::ConnectivityMethod& _internal_tcp() const; - ::dht::ConnectivityMethod* _internal_mutable_tcp(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_tcp(); public: // .dht.ConnectivityMethod websocket = 5; bool has_websocket() const; void clear_websocket() ; const ::dht::ConnectivityMethod& websocket() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_websocket(); - ::dht::ConnectivityMethod* mutable_websocket(); - void set_allocated_websocket(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_websocket(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_websocket(); + void set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_websocket(); private: const ::dht::ConnectivityMethod& _internal_websocket() const; - ::dht::ConnectivityMethod* _internal_mutable_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_websocket(); public: // .dht.NodeType type = 2; @@ -4061,6 +4169,11 @@ class PeerDescriptor final : // @@protoc_insertion_point(class_scope:dht.PeerDescriptor) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<4, 9, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4069,21 +4182,22 @@ class PeerDescriptor final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PeerDescriptor& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr nodeid_; ::google::protobuf::internal::ArenaStringPtr publickey_; ::google::protobuf::internal::ArenaStringPtr signature_; - ::dht::ConnectivityMethod* udp_; - ::dht::ConnectivityMethod* tcp_; - ::dht::ConnectivityMethod* websocket_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE udp_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE tcp_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE websocket_; int type_; ::uint32_t region_; ::uint32_t ipaddress_; @@ -4091,34 +4205,37 @@ class PeerDescriptor final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull PeerDescriptor_class_data_; +// ------------------------------------------------------------------- -class ExternalStoreDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataRequest) */ { +class ExternalStoreDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataRequest) */ { public: inline ExternalStoreDataRequest() : ExternalStoreDataRequest(nullptr) {} - ~ExternalStoreDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR ExternalStoreDataRequest(::google::protobuf::internal::ConstantInitialized); + ~ExternalStoreDataRequest() PROTOBUF_FINAL; - inline ExternalStoreDataRequest(const ExternalStoreDataRequest& from) - : ExternalStoreDataRequest(nullptr, from) {} - ExternalStoreDataRequest(ExternalStoreDataRequest&& from) noexcept - : ExternalStoreDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalStoreDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalStoreDataRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalStoreDataRequest(::google::protobuf::internal::ConstantInitialized); + inline ExternalStoreDataRequest(const ExternalStoreDataRequest& from) : ExternalStoreDataRequest(nullptr, from) {} + inline ExternalStoreDataRequest(ExternalStoreDataRequest&& from) noexcept + : ExternalStoreDataRequest(nullptr, ::std::move(from)) {} inline ExternalStoreDataRequest& operator=(const ExternalStoreDataRequest& from) { CopyFrom(from); return *this; } inline ExternalStoreDataRequest& operator=(ExternalStoreDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4130,47 +4247,35 @@ class ExternalStoreDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalStoreDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalStoreDataRequest* internal_default_instance() { - return reinterpret_cast( - &_ExternalStoreDataRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(ExternalStoreDataRequest& a, ExternalStoreDataRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ExternalStoreDataRequest_default_instance_); } - inline void Swap(ExternalStoreDataRequest* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(ExternalStoreDataRequest& a, ExternalStoreDataRequest& b) { a.Swap(&b); } + inline void Swap(ExternalStoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalStoreDataRequest* other) { + void UnsafeArenaSwap(ExternalStoreDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4178,71 +4283,82 @@ class ExternalStoreDataRequest final : // implements Message ---------------------------------------------- - ExternalStoreDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalStoreDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalStoreDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalStoreDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalStoreDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalStoreDataRequest"; } + + explicit ExternalStoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalStoreDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataRequest& from); + ExternalStoreDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalStoreDataRequest&& from) noexcept + : ExternalStoreDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalStoreDataRequest(::google::protobuf::Arena* arena); - ExternalStoreDataRequest(::google::protobuf::Arena* arena, const ExternalStoreDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, kDataFieldNumber = 2, }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // .google.protobuf.Any data = 2; bool has_data() const; void clear_data() ; const ::google::protobuf::Any& data() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); - ::google::protobuf::Any* mutable_data(); - void set_allocated_data(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_data(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_data(); + void set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_data(); private: const ::google::protobuf::Any& _internal_data() const; - ::google::protobuf::Any* _internal_mutable_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_data(); public: // @@protoc_insertion_point(class_scope:dht.ExternalStoreDataRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4251,49 +4367,53 @@ class ExternalStoreDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalStoreDataRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; - ::google::protobuf::Any* data_; + ::google::protobuf::Any* PROTOBUF_NULLABLE data_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataRequest_class_data_; +// ------------------------------------------------------------------- -class DataEntry final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.DataEntry) */ { +class DataEntry final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.DataEntry) */ { public: inline DataEntry() : DataEntry(nullptr) {} - ~DataEntry() override; - template - explicit PROTOBUF_CONSTEXPR DataEntry(::google::protobuf::internal::ConstantInitialized); + ~DataEntry() PROTOBUF_FINAL; - inline DataEntry(const DataEntry& from) - : DataEntry(nullptr, from) {} - DataEntry(DataEntry&& from) noexcept - : DataEntry() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DataEntry* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DataEntry)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR DataEntry(::google::protobuf::internal::ConstantInitialized); + inline DataEntry(const DataEntry& from) : DataEntry(nullptr, from) {} + inline DataEntry(DataEntry&& from) noexcept + : DataEntry(nullptr, ::std::move(from)) {} inline DataEntry& operator=(const DataEntry& from) { CopyFrom(from); return *this; } inline DataEntry& operator=(DataEntry&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4305,47 +4425,35 @@ class DataEntry final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const DataEntry& default_instance() { - return *internal_default_instance(); - } - static inline const DataEntry* internal_default_instance() { - return reinterpret_cast( - &_DataEntry_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(DataEntry& a, DataEntry& b) { - a.Swap(&b); + return *reinterpret_cast( + &_DataEntry_default_instance_); } - inline void Swap(DataEntry* other) { + static constexpr int kIndexInFileMessages = 5; + friend void swap(DataEntry& a, DataEntry& b) { a.Swap(&b); } + inline void Swap(DataEntry* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(DataEntry* other) { + void UnsafeArenaSwap(DataEntry* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4353,33 +4461,40 @@ class DataEntry final : // implements Message ---------------------------------------------- - DataEntry* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + DataEntry* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(DataEntry* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.DataEntry"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(DataEntry* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.DataEntry"; } + + explicit DataEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + DataEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DataEntry& from); + DataEntry( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DataEntry&& from) noexcept + : DataEntry(arena) { + *this = ::std::move(from); } - protected: - explicit DataEntry(::google::protobuf::Arena* arena); - DataEntry(::google::protobuf::Arena* arena, const DataEntry& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kKeyFieldNumber = 1, kCreatorFieldNumber = 3, @@ -4392,79 +4507,77 @@ class DataEntry final : }; // bytes key = 1; void clear_key() ; - const std::string& key() const; - template + const ::std::string& key() const; + template void set_key(Arg_&& arg, Args_... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_key(); + void set_allocated_key(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( - const std::string& value); - std::string* _internal_mutable_key(); + const ::std::string& _internal_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_key(); public: // bytes creator = 3; void clear_creator() ; - const std::string& creator() const; - template + const ::std::string& creator() const; + template void set_creator(Arg_&& arg, Args_... args); - std::string* mutable_creator(); - PROTOBUF_NODISCARD std::string* release_creator(); - void set_allocated_creator(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_creator(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_creator(); + void set_allocated_creator(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_creator() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_creator( - const std::string& value); - std::string* _internal_mutable_creator(); + const ::std::string& _internal_creator() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_creator(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_creator(); public: // .google.protobuf.Any data = 2; bool has_data() const; void clear_data() ; const ::google::protobuf::Any& data() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_data(); - ::google::protobuf::Any* mutable_data(); - void set_allocated_data(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_data(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_data(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_data(); + void set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_data(); private: const ::google::protobuf::Any& _internal_data() const; - ::google::protobuf::Any* _internal_mutable_data(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_data(); public: // .google.protobuf.Timestamp createdAt = 4; bool has_createdat() const; void clear_createdat() ; const ::google::protobuf::Timestamp& createdat() const; - PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_createdat(); - ::google::protobuf::Timestamp* mutable_createdat(); - void set_allocated_createdat(::google::protobuf::Timestamp* value); - void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value); - ::google::protobuf::Timestamp* unsafe_arena_release_createdat(); + [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_createdat(); + void set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_createdat(); private: const ::google::protobuf::Timestamp& _internal_createdat() const; - ::google::protobuf::Timestamp* _internal_mutable_createdat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_createdat(); public: // .google.protobuf.Timestamp storedAt = 5; bool has_storedat() const; void clear_storedat() ; const ::google::protobuf::Timestamp& storedat() const; - PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_storedat(); - ::google::protobuf::Timestamp* mutable_storedat(); - void set_allocated_storedat(::google::protobuf::Timestamp* value); - void unsafe_arena_set_allocated_storedat(::google::protobuf::Timestamp* value); - ::google::protobuf::Timestamp* unsafe_arena_release_storedat(); + [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_storedat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_storedat(); + void set_allocated_storedat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_storedat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value); + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_storedat(); private: const ::google::protobuf::Timestamp& _internal_storedat() const; - ::google::protobuf::Timestamp* _internal_mutable_storedat(); + ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_storedat(); public: // uint32 ttl = 6; @@ -4500,6 +4613,11 @@ class DataEntry final : // @@protoc_insertion_point(class_scope:dht.DataEntry) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 8, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4508,20 +4626,21 @@ class DataEntry final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const DataEntry& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr key_; ::google::protobuf::internal::ArenaStringPtr creator_; - ::google::protobuf::Any* data_; - ::google::protobuf::Timestamp* createdat_; - ::google::protobuf::Timestamp* storedat_; + ::google::protobuf::Any* PROTOBUF_NULLABLE data_; + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE createdat_; + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE storedat_; ::uint32_t ttl_; bool stale_; bool deleted_; @@ -4529,34 +4648,37 @@ class DataEntry final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull DataEntry_class_data_; +// ------------------------------------------------------------------- -class ConnectivityResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ConnectivityResponse) */ { +class ConnectivityResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ConnectivityResponse) */ { public: inline ConnectivityResponse() : ConnectivityResponse(nullptr) {} - ~ConnectivityResponse() override; - template - explicit PROTOBUF_CONSTEXPR ConnectivityResponse(::google::protobuf::internal::ConstantInitialized); + ~ConnectivityResponse() PROTOBUF_FINAL; - inline ConnectivityResponse(const ConnectivityResponse& from) - : ConnectivityResponse(nullptr, from) {} - ConnectivityResponse(ConnectivityResponse&& from) noexcept - : ConnectivityResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConnectivityResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConnectivityResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConnectivityResponse(::google::protobuf::internal::ConstantInitialized); + inline ConnectivityResponse(const ConnectivityResponse& from) : ConnectivityResponse(nullptr, from) {} + inline ConnectivityResponse(ConnectivityResponse&& from) noexcept + : ConnectivityResponse(nullptr, ::std::move(from)) {} inline ConnectivityResponse& operator=(const ConnectivityResponse& from) { CopyFrom(from); return *this; } inline ConnectivityResponse& operator=(ConnectivityResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4568,47 +4690,35 @@ class ConnectivityResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ConnectivityResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ConnectivityResponse_default_instance_); } - static inline const ConnectivityResponse* internal_default_instance() { - return reinterpret_cast( - &_ConnectivityResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(ConnectivityResponse& a, ConnectivityResponse& b) { - a.Swap(&b); - } - inline void Swap(ConnectivityResponse* other) { + static constexpr int kIndexInFileMessages = 20; + friend void swap(ConnectivityResponse& a, ConnectivityResponse& b) { a.Swap(&b); } + inline void Swap(ConnectivityResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ConnectivityResponse* other) { + void UnsafeArenaSwap(ConnectivityResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4616,33 +4726,40 @@ class ConnectivityResponse final : // implements Message ---------------------------------------------- - ConnectivityResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ConnectivityResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ConnectivityResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ConnectivityResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConnectivityResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ConnectivityResponse"; } + + explicit ConnectivityResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ConnectivityResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConnectivityResponse& from); + ConnectivityResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ConnectivityResponse&& from) noexcept + : ConnectivityResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ConnectivityResponse(::google::protobuf::Arena* arena); - ConnectivityResponse(::google::protobuf::Arena* arena, const ConnectivityResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kHostFieldNumber = 1, kNatTypeFieldNumber = 2, @@ -4654,65 +4771,62 @@ class ConnectivityResponse final : }; // string host = 1; void clear_host() ; - const std::string& host() const; - template + const ::std::string& host() const; + template void set_host(Arg_&& arg, Args_... args); - std::string* mutable_host(); - PROTOBUF_NODISCARD std::string* release_host(); - void set_allocated_host(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_host(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host(); + void set_allocated_host(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_host() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( - const std::string& value); - std::string* _internal_mutable_host(); + const ::std::string& _internal_host() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_host(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_host(); public: // string natType = 2; void clear_nattype() ; - const std::string& nattype() const; - template + const ::std::string& nattype() const; + template void set_nattype(Arg_&& arg, Args_... args); - std::string* mutable_nattype(); - PROTOBUF_NODISCARD std::string* release_nattype(); - void set_allocated_nattype(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_nattype(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_nattype(); + void set_allocated_nattype(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_nattype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_nattype( - const std::string& value); - std::string* _internal_mutable_nattype(); + const ::std::string& _internal_nattype() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_nattype(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_nattype(); public: // string version = 5; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.ConnectivityMethod websocket = 3; bool has_websocket() const; void clear_websocket() ; const ::dht::ConnectivityMethod& websocket() const; - PROTOBUF_NODISCARD ::dht::ConnectivityMethod* release_websocket(); - ::dht::ConnectivityMethod* mutable_websocket(); - void set_allocated_websocket(::dht::ConnectivityMethod* value); - void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value); - ::dht::ConnectivityMethod* unsafe_arena_release_websocket(); + [[nodiscard]] ::dht::ConnectivityMethod* PROTOBUF_NULLABLE release_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL mutable_websocket(); + void set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value); + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE unsafe_arena_release_websocket(); private: const ::dht::ConnectivityMethod& _internal_websocket() const; - ::dht::ConnectivityMethod* _internal_mutable_websocket(); + ::dht::ConnectivityMethod* PROTOBUF_NONNULL _internal_mutable_websocket(); public: // optional double latitude = 6; @@ -4750,6 +4864,11 @@ class ConnectivityResponse final : // @@protoc_insertion_point(class_scope:dht.ConnectivityResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 1, 51, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4758,19 +4877,20 @@ class ConnectivityResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ConnectivityResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr host_; ::google::protobuf::internal::ArenaStringPtr nattype_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::ConnectivityMethod* websocket_; + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE websocket_; double latitude_; double longitude_; ::uint32_t ipaddress_; @@ -4778,34 +4898,37 @@ class ConnectivityResponse final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ConnectivityResponse_class_data_; +// ------------------------------------------------------------------- -class ReplicateDataRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ReplicateDataRequest) */ { +class ReplicateDataRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ReplicateDataRequest) */ { public: inline ReplicateDataRequest() : ReplicateDataRequest(nullptr) {} - ~ReplicateDataRequest() override; - template - explicit PROTOBUF_CONSTEXPR ReplicateDataRequest(::google::protobuf::internal::ConstantInitialized); + ~ReplicateDataRequest() PROTOBUF_FINAL; - inline ReplicateDataRequest(const ReplicateDataRequest& from) - : ReplicateDataRequest(nullptr, from) {} - ReplicateDataRequest(ReplicateDataRequest&& from) noexcept - : ReplicateDataRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ReplicateDataRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ReplicateDataRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ReplicateDataRequest(::google::protobuf::internal::ConstantInitialized); + inline ReplicateDataRequest(const ReplicateDataRequest& from) : ReplicateDataRequest(nullptr, from) {} + inline ReplicateDataRequest(ReplicateDataRequest&& from) noexcept + : ReplicateDataRequest(nullptr, ::std::move(from)) {} inline ReplicateDataRequest& operator=(const ReplicateDataRequest& from) { CopyFrom(from); return *this; } inline ReplicateDataRequest& operator=(ReplicateDataRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4817,47 +4940,35 @@ class ReplicateDataRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ReplicateDataRequest& default_instance() { - return *internal_default_instance(); - } - static inline const ReplicateDataRequest* internal_default_instance() { - return reinterpret_cast( - &_ReplicateDataRequest_default_instance_); + return *reinterpret_cast( + &_ReplicateDataRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(ReplicateDataRequest& a, ReplicateDataRequest& b) { - a.Swap(&b); - } - inline void Swap(ReplicateDataRequest* other) { + static constexpr int kIndexInFileMessages = 4; + friend void swap(ReplicateDataRequest& a, ReplicateDataRequest& b) { a.Swap(&b); } + inline void Swap(ReplicateDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ReplicateDataRequest* other) { + void UnsafeArenaSwap(ReplicateDataRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4865,33 +4976,40 @@ class ReplicateDataRequest final : // implements Message ---------------------------------------------- - ReplicateDataRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ReplicateDataRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ReplicateDataRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ReplicateDataRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ReplicateDataRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ReplicateDataRequest"; } + + explicit ReplicateDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ReplicateDataRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ReplicateDataRequest& from); + ReplicateDataRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ReplicateDataRequest&& from) noexcept + : ReplicateDataRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ReplicateDataRequest(::google::protobuf::Arena* arena); - ReplicateDataRequest(::google::protobuf::Arena* arena, const ReplicateDataRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEntryFieldNumber = 1, }; @@ -4899,20 +5017,25 @@ class ReplicateDataRequest final : bool has_entry() const; void clear_entry() ; const ::dht::DataEntry& entry() const; - PROTOBUF_NODISCARD ::dht::DataEntry* release_entry(); - ::dht::DataEntry* mutable_entry(); - void set_allocated_entry(::dht::DataEntry* value); - void unsafe_arena_set_allocated_entry(::dht::DataEntry* value); - ::dht::DataEntry* unsafe_arena_release_entry(); + [[nodiscard]] ::dht::DataEntry* PROTOBUF_NULLABLE release_entry(); + ::dht::DataEntry* PROTOBUF_NONNULL mutable_entry(); + void set_allocated_entry(::dht::DataEntry* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_entry(::dht::DataEntry* PROTOBUF_NULLABLE value); + ::dht::DataEntry* PROTOBUF_NULLABLE unsafe_arena_release_entry(); private: const ::dht::DataEntry& _internal_entry() const; - ::dht::DataEntry* _internal_mutable_entry(); + ::dht::DataEntry* PROTOBUF_NONNULL _internal_mutable_entry(); public: // @@protoc_insertion_point(class_scope:dht.ReplicateDataRequest) 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; @@ -4921,48 +5044,52 @@ class ReplicateDataRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ReplicateDataRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::dht::DataEntry* entry_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::dht::DataEntry* PROTOBUF_NULLABLE entry_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class RecursiveOperationResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RecursiveOperationResponse) */ { +extern const ::google::protobuf::internal::ClassDataFull ReplicateDataRequest_class_data_; +// ------------------------------------------------------------------- + +class RecursiveOperationResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RecursiveOperationResponse) */ { public: inline RecursiveOperationResponse() : RecursiveOperationResponse(nullptr) {} - ~RecursiveOperationResponse() override; - template - explicit PROTOBUF_CONSTEXPR RecursiveOperationResponse(::google::protobuf::internal::ConstantInitialized); + ~RecursiveOperationResponse() PROTOBUF_FINAL; - inline RecursiveOperationResponse(const RecursiveOperationResponse& from) - : RecursiveOperationResponse(nullptr, from) {} - RecursiveOperationResponse(RecursiveOperationResponse&& from) noexcept - : RecursiveOperationResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RecursiveOperationResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RecursiveOperationResponse)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RecursiveOperationResponse(::google::protobuf::internal::ConstantInitialized); + + inline RecursiveOperationResponse(const RecursiveOperationResponse& from) : RecursiveOperationResponse(nullptr, from) {} + inline RecursiveOperationResponse(RecursiveOperationResponse&& from) noexcept + : RecursiveOperationResponse(nullptr, ::std::move(from)) {} inline RecursiveOperationResponse& operator=(const RecursiveOperationResponse& from) { CopyFrom(from); return *this; } inline RecursiveOperationResponse& operator=(RecursiveOperationResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4974,47 +5101,35 @@ class RecursiveOperationResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RecursiveOperationResponse& default_instance() { - return *internal_default_instance(); - } - static inline const RecursiveOperationResponse* internal_default_instance() { - return reinterpret_cast( - &_RecursiveOperationResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(RecursiveOperationResponse& a, RecursiveOperationResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RecursiveOperationResponse_default_instance_); } - inline void Swap(RecursiveOperationResponse* other) { + static constexpr int kIndexInFileMessages = 11; + friend void swap(RecursiveOperationResponse& a, RecursiveOperationResponse& b) { a.Swap(&b); } + inline void Swap(RecursiveOperationResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RecursiveOperationResponse* other) { + void UnsafeArenaSwap(RecursiveOperationResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5022,33 +5137,40 @@ class RecursiveOperationResponse final : // implements Message ---------------------------------------------- - RecursiveOperationResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RecursiveOperationResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RecursiveOperationResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RecursiveOperationResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RecursiveOperationResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RecursiveOperationResponse"; } + + explicit RecursiveOperationResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RecursiveOperationResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RecursiveOperationResponse& from); + RecursiveOperationResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RecursiveOperationResponse&& from) noexcept + : RecursiveOperationResponse(arena) { + *this = ::std::move(from); } - protected: - explicit RecursiveOperationResponse(::google::protobuf::Arena* arena); - RecursiveOperationResponse(::google::protobuf::Arena* arena, const RecursiveOperationResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kClosestConnectedNodesFieldNumber = 1, kDataEntriesFieldNumber = 2, @@ -5062,17 +5184,16 @@ class RecursiveOperationResponse final : public: void clear_closestconnectednodes() ; - ::dht::PeerDescriptor* mutable_closestconnectednodes(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_closestconnectednodes(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_closestconnectednodes(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_closestconnectednodes(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_closestconnectednodes() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_closestconnectednodes(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_closestconnectednodes(); public: const ::dht::PeerDescriptor& closestconnectednodes(int index) const; - ::dht::PeerDescriptor* add_closestconnectednodes(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - closestconnectednodes() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_closestconnectednodes(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& closestconnectednodes() const; // repeated .dht.DataEntry dataEntries = 2; int dataentries_size() const; private: @@ -5080,17 +5201,16 @@ class RecursiveOperationResponse final : public: void clear_dataentries() ; - ::dht::DataEntry* mutable_dataentries(int index); - ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >* - mutable_dataentries(); + ::dht::DataEntry* PROTOBUF_NONNULL mutable_dataentries(int index); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL mutable_dataentries(); + private: const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& _internal_dataentries() const; - ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* _internal_mutable_dataentries(); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL _internal_mutable_dataentries(); public: const ::dht::DataEntry& dataentries(int index) const; - ::dht::DataEntry* add_dataentries(); - const ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >& - dataentries() const; + ::dht::DataEntry* PROTOBUF_NONNULL add_dataentries(); + const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& dataentries() const; // repeated .dht.PeerDescriptor routingPath = 4; int routingpath_size() const; private: @@ -5098,17 +5218,16 @@ class RecursiveOperationResponse final : public: void clear_routingpath() ; - ::dht::PeerDescriptor* mutable_routingpath(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_routingpath(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_routingpath(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_routingpath(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_routingpath() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_routingpath(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_routingpath(); public: const ::dht::PeerDescriptor& routingpath(int index) const; - ::dht::PeerDescriptor* add_routingpath(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - routingpath() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_routingpath(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& routingpath() const; // bool noCloserNodesFound = 3; void clear_noclosernodesfound() ; bool noclosernodesfound() const; @@ -5122,6 +5241,11 @@ class RecursiveOperationResponse final : // @@protoc_insertion_point(class_scope:dht.RecursiveOperationResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 3, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -5130,50 +5254,55 @@ class RecursiveOperationResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RecursiveOperationResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > closestconnectednodes_; ::google::protobuf::RepeatedPtrField< ::dht::DataEntry > dataentries_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > routingpath_; bool noclosernodesfound_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RecursiveOperationResponse_class_data_; +// ------------------------------------------------------------------- -class HandshakeResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.HandshakeResponse) */ { +class HandshakeResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.HandshakeResponse) */ { public: inline HandshakeResponse() : HandshakeResponse(nullptr) {} - ~HandshakeResponse() override; - template - explicit PROTOBUF_CONSTEXPR HandshakeResponse(::google::protobuf::internal::ConstantInitialized); + ~HandshakeResponse() PROTOBUF_FINAL; - inline HandshakeResponse(const HandshakeResponse& from) - : HandshakeResponse(nullptr, from) {} - HandshakeResponse(HandshakeResponse&& from) noexcept - : HandshakeResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HandshakeResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HandshakeResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HandshakeResponse(::google::protobuf::internal::ConstantInitialized); + inline HandshakeResponse(const HandshakeResponse& from) : HandshakeResponse(nullptr, from) {} + inline HandshakeResponse(HandshakeResponse&& from) noexcept + : HandshakeResponse(nullptr, ::std::move(from)) {} inline HandshakeResponse& operator=(const HandshakeResponse& from) { CopyFrom(from); return *this; } inline HandshakeResponse& operator=(HandshakeResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5185,47 +5314,35 @@ class HandshakeResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HandshakeResponse& default_instance() { - return *internal_default_instance(); - } - static inline const HandshakeResponse* internal_default_instance() { - return reinterpret_cast( - &_HandshakeResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 22; - - friend void swap(HandshakeResponse& a, HandshakeResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_HandshakeResponse_default_instance_); } - inline void Swap(HandshakeResponse* other) { + static constexpr int kIndexInFileMessages = 22; + friend void swap(HandshakeResponse& a, HandshakeResponse& b) { a.Swap(&b); } + inline void Swap(HandshakeResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HandshakeResponse* other) { + void UnsafeArenaSwap(HandshakeResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5233,33 +5350,40 @@ class HandshakeResponse final : // implements Message ---------------------------------------------- - HandshakeResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HandshakeResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HandshakeResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.HandshakeResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HandshakeResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.HandshakeResponse"; } + + explicit HandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeResponse& from); + HandshakeResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HandshakeResponse&& from) noexcept + : HandshakeResponse(arena) { + *this = ::std::move(from); } - protected: - explicit HandshakeResponse(::google::protobuf::Arena* arena); - HandshakeResponse(::google::protobuf::Arena* arena, const HandshakeResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kVersionFieldNumber = 3, kSourcePeerDescriptorFieldNumber = 1, @@ -5267,33 +5391,32 @@ class HandshakeResponse final : }; // string version = 3; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.PeerDescriptor sourcePeerDescriptor = 1; bool has_sourcepeerdescriptor() const; void clear_sourcepeerdescriptor() ; const ::dht::PeerDescriptor& sourcepeerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcepeerdescriptor(); - ::dht::PeerDescriptor* mutable_sourcepeerdescriptor(); - void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcepeerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeerdescriptor(); + void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeerdescriptor(); private: const ::dht::PeerDescriptor& _internal_sourcepeerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeerdescriptor(); public: // optional .dht.HandshakeError error = 2; @@ -5310,6 +5433,11 @@ class HandshakeResponse final : // @@protoc_insertion_point(class_scope:dht.HandshakeResponse) 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; @@ -5318,50 +5446,54 @@ class HandshakeResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HandshakeResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::PeerDescriptor* sourcepeerdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcepeerdescriptor_; int error_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull HandshakeResponse_class_data_; +// ------------------------------------------------------------------- -class HandshakeRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.HandshakeRequest) */ { +class HandshakeRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.HandshakeRequest) */ { public: inline HandshakeRequest() : HandshakeRequest(nullptr) {} - ~HandshakeRequest() override; - template - explicit PROTOBUF_CONSTEXPR HandshakeRequest(::google::protobuf::internal::ConstantInitialized); + ~HandshakeRequest() PROTOBUF_FINAL; - inline HandshakeRequest(const HandshakeRequest& from) - : HandshakeRequest(nullptr, from) {} - HandshakeRequest(HandshakeRequest&& from) noexcept - : HandshakeRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(HandshakeRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(HandshakeRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR HandshakeRequest(::google::protobuf::internal::ConstantInitialized); + inline HandshakeRequest(const HandshakeRequest& from) : HandshakeRequest(nullptr, from) {} + inline HandshakeRequest(HandshakeRequest&& from) noexcept + : HandshakeRequest(nullptr, ::std::move(from)) {} inline HandshakeRequest& operator=(const HandshakeRequest& from) { CopyFrom(from); return *this; } inline HandshakeRequest& operator=(HandshakeRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5373,47 +5505,35 @@ class HandshakeRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const HandshakeRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_HandshakeRequest_default_instance_); } - static inline const HandshakeRequest* internal_default_instance() { - return reinterpret_cast( - &_HandshakeRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(HandshakeRequest& a, HandshakeRequest& b) { - a.Swap(&b); - } - inline void Swap(HandshakeRequest* other) { + static constexpr int kIndexInFileMessages = 21; + friend void swap(HandshakeRequest& a, HandshakeRequest& b) { a.Swap(&b); } + inline void Swap(HandshakeRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(HandshakeRequest* other) { + void UnsafeArenaSwap(HandshakeRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5421,33 +5541,40 @@ class HandshakeRequest final : // implements Message ---------------------------------------------- - HandshakeRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + HandshakeRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(HandshakeRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.HandshakeRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(HandshakeRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.HandshakeRequest"; } + + explicit HandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + HandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HandshakeRequest& from); + HandshakeRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HandshakeRequest&& from) noexcept + : HandshakeRequest(arena) { + *this = ::std::move(from); } - protected: - explicit HandshakeRequest(::google::protobuf::Arena* arena); - HandshakeRequest(::google::protobuf::Arena* arena, const HandshakeRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kVersionFieldNumber = 3, kSourcePeerDescriptorFieldNumber = 1, @@ -5455,53 +5582,57 @@ class HandshakeRequest final : }; // string version = 3; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.PeerDescriptor sourcePeerDescriptor = 1; bool has_sourcepeerdescriptor() const; void clear_sourcepeerdescriptor() ; const ::dht::PeerDescriptor& sourcepeerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcepeerdescriptor(); - ::dht::PeerDescriptor* mutable_sourcepeerdescriptor(); - void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcepeerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeerdescriptor(); + void set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeerdescriptor(); private: const ::dht::PeerDescriptor& _internal_sourcepeerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_sourcepeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeerdescriptor(); public: // optional .dht.PeerDescriptor targetPeerDescriptor = 2; bool has_targetpeerdescriptor() const; void clear_targetpeerdescriptor() ; const ::dht::PeerDescriptor& targetpeerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_targetpeerdescriptor(); - ::dht::PeerDescriptor* mutable_targetpeerdescriptor(); - void set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_targetpeerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_targetpeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_targetpeerdescriptor(); + void set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_targetpeerdescriptor(); private: const ::dht::PeerDescriptor& _internal_targetpeerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_targetpeerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_targetpeerdescriptor(); public: // @@protoc_insertion_point(class_scope:dht.HandshakeRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 36, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -5510,50 +5641,54 @@ class HandshakeRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const HandshakeRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::PeerDescriptor* sourcepeerdescriptor_; - ::dht::PeerDescriptor* targetpeerdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcepeerdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE targetpeerdescriptor_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull HandshakeRequest_class_data_; +// ------------------------------------------------------------------- -class ExternalStoreDataResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataResponse) */ { +class ExternalStoreDataResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalStoreDataResponse) */ { public: inline ExternalStoreDataResponse() : ExternalStoreDataResponse(nullptr) {} - ~ExternalStoreDataResponse() override; - template - explicit PROTOBUF_CONSTEXPR ExternalStoreDataResponse(::google::protobuf::internal::ConstantInitialized); + ~ExternalStoreDataResponse() PROTOBUF_FINAL; - inline ExternalStoreDataResponse(const ExternalStoreDataResponse& from) - : ExternalStoreDataResponse(nullptr, from) {} - ExternalStoreDataResponse(ExternalStoreDataResponse&& from) noexcept - : ExternalStoreDataResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalStoreDataResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalStoreDataResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalStoreDataResponse(::google::protobuf::internal::ConstantInitialized); + inline ExternalStoreDataResponse(const ExternalStoreDataResponse& from) : ExternalStoreDataResponse(nullptr, from) {} + inline ExternalStoreDataResponse(ExternalStoreDataResponse&& from) noexcept + : ExternalStoreDataResponse(nullptr, ::std::move(from)) {} inline ExternalStoreDataResponse& operator=(const ExternalStoreDataResponse& from) { CopyFrom(from); return *this; } inline ExternalStoreDataResponse& operator=(ExternalStoreDataResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5565,47 +5700,35 @@ class ExternalStoreDataResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalStoreDataResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalStoreDataResponse* internal_default_instance() { - return reinterpret_cast( - &_ExternalStoreDataResponse_default_instance_); + return *reinterpret_cast( + &_ExternalStoreDataResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(ExternalStoreDataResponse& a, ExternalStoreDataResponse& b) { - a.Swap(&b); - } - inline void Swap(ExternalStoreDataResponse* other) { + static constexpr int kIndexInFileMessages = 3; + friend void swap(ExternalStoreDataResponse& a, ExternalStoreDataResponse& b) { a.Swap(&b); } + inline void Swap(ExternalStoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalStoreDataResponse* other) { + void UnsafeArenaSwap(ExternalStoreDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5613,33 +5736,40 @@ class ExternalStoreDataResponse final : // implements Message ---------------------------------------------- - ExternalStoreDataResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalStoreDataResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalStoreDataResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalStoreDataResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalStoreDataResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalStoreDataResponse"; } + + explicit ExternalStoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalStoreDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalStoreDataResponse& from); + ExternalStoreDataResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalStoreDataResponse&& from) noexcept + : ExternalStoreDataResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalStoreDataResponse(::google::protobuf::Arena* arena); - ExternalStoreDataResponse(::google::protobuf::Arena* arena, const ExternalStoreDataResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kStorersFieldNumber = 1, }; @@ -5650,20 +5780,24 @@ class ExternalStoreDataResponse final : public: void clear_storers() ; - ::dht::PeerDescriptor* mutable_storers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_storers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_storers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_storers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_storers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_storers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_storers(); public: const ::dht::PeerDescriptor& storers(int index) const; - ::dht::PeerDescriptor* add_storers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - storers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_storers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& storers() const; // @@protoc_insertion_point(class_scope:dht.ExternalStoreDataResponse) 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; @@ -5672,47 +5806,52 @@ class ExternalStoreDataResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalStoreDataResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > storers_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ExternalStoreDataResponse_class_data_; +// ------------------------------------------------------------------- -class ExternalFetchDataResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataResponse) */ { +class ExternalFetchDataResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ExternalFetchDataResponse) */ { public: inline ExternalFetchDataResponse() : ExternalFetchDataResponse(nullptr) {} - ~ExternalFetchDataResponse() override; - template - explicit PROTOBUF_CONSTEXPR ExternalFetchDataResponse(::google::protobuf::internal::ConstantInitialized); + ~ExternalFetchDataResponse() PROTOBUF_FINAL; - inline ExternalFetchDataResponse(const ExternalFetchDataResponse& from) - : ExternalFetchDataResponse(nullptr, from) {} - ExternalFetchDataResponse(ExternalFetchDataResponse&& from) noexcept - : ExternalFetchDataResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ExternalFetchDataResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalFetchDataResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ExternalFetchDataResponse(::google::protobuf::internal::ConstantInitialized); + inline ExternalFetchDataResponse(const ExternalFetchDataResponse& from) : ExternalFetchDataResponse(nullptr, from) {} + inline ExternalFetchDataResponse(ExternalFetchDataResponse&& from) noexcept + : ExternalFetchDataResponse(nullptr, ::std::move(from)) {} inline ExternalFetchDataResponse& operator=(const ExternalFetchDataResponse& from) { CopyFrom(from); return *this; } inline ExternalFetchDataResponse& operator=(ExternalFetchDataResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5724,47 +5863,35 @@ class ExternalFetchDataResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ExternalFetchDataResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ExternalFetchDataResponse_default_instance_); } - static inline const ExternalFetchDataResponse* internal_default_instance() { - return reinterpret_cast( - &_ExternalFetchDataResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 34; - - friend void swap(ExternalFetchDataResponse& a, ExternalFetchDataResponse& b) { - a.Swap(&b); - } - inline void Swap(ExternalFetchDataResponse* other) { + static constexpr int kIndexInFileMessages = 34; + friend void swap(ExternalFetchDataResponse& a, ExternalFetchDataResponse& b) { a.Swap(&b); } + inline void Swap(ExternalFetchDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ExternalFetchDataResponse* other) { + void UnsafeArenaSwap(ExternalFetchDataResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5772,33 +5899,40 @@ class ExternalFetchDataResponse final : // implements Message ---------------------------------------------- - ExternalFetchDataResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ExternalFetchDataResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ExternalFetchDataResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ExternalFetchDataResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ExternalFetchDataResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ExternalFetchDataResponse"; } + + explicit ExternalFetchDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ExternalFetchDataResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalFetchDataResponse& from); + ExternalFetchDataResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalFetchDataResponse&& from) noexcept + : ExternalFetchDataResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ExternalFetchDataResponse(::google::protobuf::Arena* arena); - ExternalFetchDataResponse(::google::protobuf::Arena* arena, const ExternalFetchDataResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEntriesFieldNumber = 1, }; @@ -5809,20 +5943,24 @@ class ExternalFetchDataResponse final : public: void clear_entries() ; - ::dht::DataEntry* mutable_entries(int index); - ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >* - mutable_entries(); + ::dht::DataEntry* PROTOBUF_NONNULL mutable_entries(int index); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL mutable_entries(); + private: const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& _internal_entries() const; - ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* _internal_mutable_entries(); + ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL _internal_mutable_entries(); public: const ::dht::DataEntry& entries(int index) const; - ::dht::DataEntry* add_entries(); - const ::google::protobuf::RepeatedPtrField< ::dht::DataEntry >& - entries() const; + ::dht::DataEntry* PROTOBUF_NONNULL add_entries(); + const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& entries() const; // @@protoc_insertion_point(class_scope:dht.ExternalFetchDataResponse) 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; @@ -5831,47 +5969,52 @@ class ExternalFetchDataResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ExternalFetchDataResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::DataEntry > entries_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ExternalFetchDataResponse_class_data_; +// ------------------------------------------------------------------- -class ClosestRingPeersResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersResponse) */ { +class ClosestRingPeersResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestRingPeersResponse) */ { public: inline ClosestRingPeersResponse() : ClosestRingPeersResponse(nullptr) {} - ~ClosestRingPeersResponse() override; - template - explicit PROTOBUF_CONSTEXPR ClosestRingPeersResponse(::google::protobuf::internal::ConstantInitialized); + ~ClosestRingPeersResponse() PROTOBUF_FINAL; - inline ClosestRingPeersResponse(const ClosestRingPeersResponse& from) - : ClosestRingPeersResponse(nullptr, from) {} - ClosestRingPeersResponse(ClosestRingPeersResponse&& from) noexcept - : ClosestRingPeersResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestRingPeersResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestRingPeersResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestRingPeersResponse(::google::protobuf::internal::ConstantInitialized); + inline ClosestRingPeersResponse(const ClosestRingPeersResponse& from) : ClosestRingPeersResponse(nullptr, from) {} + inline ClosestRingPeersResponse(ClosestRingPeersResponse&& from) noexcept + : ClosestRingPeersResponse(nullptr, ::std::move(from)) {} inline ClosestRingPeersResponse& operator=(const ClosestRingPeersResponse& from) { CopyFrom(from); return *this; } inline ClosestRingPeersResponse& operator=(ClosestRingPeersResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -5883,47 +6026,35 @@ class ClosestRingPeersResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestRingPeersResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestRingPeersResponse* internal_default_instance() { - return reinterpret_cast( - &_ClosestRingPeersResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(ClosestRingPeersResponse& a, ClosestRingPeersResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ClosestRingPeersResponse_default_instance_); } - inline void Swap(ClosestRingPeersResponse* other) { + static constexpr int kIndexInFileMessages = 9; + friend void swap(ClosestRingPeersResponse& a, ClosestRingPeersResponse& b) { a.Swap(&b); } + inline void Swap(ClosestRingPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestRingPeersResponse* other) { + void UnsafeArenaSwap(ClosestRingPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5931,33 +6062,40 @@ class ClosestRingPeersResponse final : // implements Message ---------------------------------------------- - ClosestRingPeersResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestRingPeersResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestRingPeersResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestRingPeersResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestRingPeersResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestRingPeersResponse"; } + + explicit ClosestRingPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestRingPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestRingPeersResponse& from); + ClosestRingPeersResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestRingPeersResponse&& from) noexcept + : ClosestRingPeersResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestRingPeersResponse(::google::protobuf::Arena* arena); - ClosestRingPeersResponse(::google::protobuf::Arena* arena, const ClosestRingPeersResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kLeftPeersFieldNumber = 1, kRightPeersFieldNumber = 2, @@ -5970,17 +6108,16 @@ class ClosestRingPeersResponse final : public: void clear_leftpeers() ; - ::dht::PeerDescriptor* mutable_leftpeers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_leftpeers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_leftpeers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_leftpeers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_leftpeers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_leftpeers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_leftpeers(); public: const ::dht::PeerDescriptor& leftpeers(int index) const; - ::dht::PeerDescriptor* add_leftpeers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - leftpeers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_leftpeers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& leftpeers() const; // repeated .dht.PeerDescriptor rightPeers = 2; int rightpeers_size() const; private: @@ -5988,36 +6125,39 @@ class ClosestRingPeersResponse final : public: void clear_rightpeers() ; - ::dht::PeerDescriptor* mutable_rightpeers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_rightpeers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_rightpeers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_rightpeers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_rightpeers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_rightpeers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_rightpeers(); public: const ::dht::PeerDescriptor& rightpeers(int index) const; - ::dht::PeerDescriptor* add_rightpeers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - rightpeers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_rightpeers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& rightpeers() const; // string requestId = 3; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestRingPeersResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 46, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6026,49 +6166,54 @@ class ClosestRingPeersResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestRingPeersResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > leftpeers_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > rightpeers_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ClosestRingPeersResponse_class_data_; +// ------------------------------------------------------------------- -class ClosestPeersResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.ClosestPeersResponse) */ { +class ClosestPeersResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.ClosestPeersResponse) */ { public: inline ClosestPeersResponse() : ClosestPeersResponse(nullptr) {} - ~ClosestPeersResponse() override; - template - explicit PROTOBUF_CONSTEXPR ClosestPeersResponse(::google::protobuf::internal::ConstantInitialized); + ~ClosestPeersResponse() PROTOBUF_FINAL; - inline ClosestPeersResponse(const ClosestPeersResponse& from) - : ClosestPeersResponse(nullptr, from) {} - ClosestPeersResponse(ClosestPeersResponse&& from) noexcept - : ClosestPeersResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClosestPeersResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClosestPeersResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClosestPeersResponse(::google::protobuf::internal::ConstantInitialized); + inline ClosestPeersResponse(const ClosestPeersResponse& from) : ClosestPeersResponse(nullptr, from) {} + inline ClosestPeersResponse(ClosestPeersResponse&& from) noexcept + : ClosestPeersResponse(nullptr, ::std::move(from)) {} inline ClosestPeersResponse& operator=(const ClosestPeersResponse& from) { CopyFrom(from); return *this; } inline ClosestPeersResponse& operator=(ClosestPeersResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -6080,47 +6225,35 @@ class ClosestPeersResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ClosestPeersResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ClosestPeersResponse* internal_default_instance() { - return reinterpret_cast( - &_ClosestPeersResponse_default_instance_); + return *reinterpret_cast( + &_ClosestPeersResponse_default_instance_); } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(ClosestPeersResponse& a, ClosestPeersResponse& b) { - a.Swap(&b); - } - inline void Swap(ClosestPeersResponse* other) { + static constexpr int kIndexInFileMessages = 7; + friend void swap(ClosestPeersResponse& a, ClosestPeersResponse& b) { a.Swap(&b); } + inline void Swap(ClosestPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ClosestPeersResponse* other) { + void UnsafeArenaSwap(ClosestPeersResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -6128,33 +6261,40 @@ class ClosestPeersResponse final : // implements Message ---------------------------------------------- - ClosestPeersResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ClosestPeersResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ClosestPeersResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.ClosestPeersResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClosestPeersResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.ClosestPeersResponse"; } + + explicit ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ClosestPeersResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ClosestPeersResponse& from); + ClosestPeersResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ClosestPeersResponse&& from) noexcept + : ClosestPeersResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ClosestPeersResponse(::google::protobuf::Arena* arena); - ClosestPeersResponse(::google::protobuf::Arena* arena, const ClosestPeersResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kPeersFieldNumber = 1, kRequestIdFieldNumber = 2, @@ -6166,36 +6306,39 @@ class ClosestPeersResponse final : public: void clear_peers() ; - ::dht::PeerDescriptor* mutable_peers(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_peers(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_peers(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_peers(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_peers() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_peers(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_peers(); public: const ::dht::PeerDescriptor& peers(int index) const; - ::dht::PeerDescriptor* add_peers(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - peers() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_peers(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& peers() const; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // @@protoc_insertion_point(class_scope:dht.ClosestPeersResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 42, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6204,48 +6347,53 @@ class ClosestPeersResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ClosestPeersResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > peers_; ::google::protobuf::internal::ArenaStringPtr requestid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ClosestPeersResponse_class_data_; +// ------------------------------------------------------------------- -class Message final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.Message) */ { +class Message final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.Message) */ { public: inline Message() : Message(nullptr) {} - ~Message() override; - template - explicit PROTOBUF_CONSTEXPR Message(::google::protobuf::internal::ConstantInitialized); + ~Message() PROTOBUF_FINAL; - inline Message(const Message& from) - : Message(nullptr, from) {} - Message(Message&& from) noexcept - : Message() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Message* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Message)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR Message(::google::protobuf::internal::ConstantInitialized); + inline Message(const Message& from) : Message(nullptr, from) {} + inline Message(Message&& from) noexcept + : Message(nullptr, ::std::move(from)) {} inline Message& operator=(const Message& from) { CopyFrom(from); return *this; } inline Message& operator=(Message&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -6257,22 +6405,23 @@ class Message final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const Message& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_Message_default_instance_); } enum BodyCase { kRpcMessage = 5, @@ -6283,31 +6432,17 @@ class Message final : kRecursiveOperationRequest = 10, BODY_NOT_SET = 0, }; - - static inline const Message* internal_default_instance() { - return reinterpret_cast( - &_Message_default_instance_); - } - static constexpr int kIndexInFileMessages = - 23; - - friend void swap(Message& a, Message& b) { - a.Swap(&b); - } - inline void Swap(Message* other) { + static constexpr int kIndexInFileMessages = 23; + friend void swap(Message& a, Message& b) { a.Swap(&b); } + inline void Swap(Message* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Message* other) { + void UnsafeArenaSwap(Message* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -6315,33 +6450,40 @@ class Message final : // implements Message ---------------------------------------------- - Message* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + Message* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(Message* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.Message"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Message* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.Message"; } + + explicit Message(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + Message(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Message& from); + Message( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Message&& from) noexcept + : Message(arena) { + *this = ::std::move(from); } - protected: - explicit Message(::google::protobuf::Arena* arena); - Message(::google::protobuf::Arena* arena, const Message& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kMessageIdFieldNumber = 1, kServiceIdFieldNumber = 4, @@ -6356,64 +6498,62 @@ class Message final : }; // string messageId = 1; void clear_messageid() ; - const std::string& messageid() const; - template + const ::std::string& messageid() const; + template void set_messageid(Arg_&& arg, Args_... args); - std::string* mutable_messageid(); - PROTOBUF_NODISCARD std::string* release_messageid(); - void set_allocated_messageid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_messageid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_messageid(); + void set_allocated_messageid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_messageid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messageid( - const std::string& value); - std::string* _internal_mutable_messageid(); + const ::std::string& _internal_messageid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_messageid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_messageid(); public: // string serviceId = 4; void clear_serviceid() ; - const std::string& serviceid() const; - template + const ::std::string& serviceid() const; + template void set_serviceid(Arg_&& arg, Args_... args); - std::string* mutable_serviceid(); - PROTOBUF_NODISCARD std::string* release_serviceid(); - void set_allocated_serviceid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_serviceid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_serviceid(); + void set_allocated_serviceid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_serviceid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_serviceid( - const std::string& value); - std::string* _internal_mutable_serviceid(); + const ::std::string& _internal_serviceid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_serviceid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_serviceid(); public: // .dht.PeerDescriptor sourceDescriptor = 2; bool has_sourcedescriptor() const; void clear_sourcedescriptor() ; const ::dht::PeerDescriptor& sourcedescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcedescriptor(); - ::dht::PeerDescriptor* mutable_sourcedescriptor(); - void set_allocated_sourcedescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcedescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcedescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcedescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcedescriptor(); + void set_allocated_sourcedescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcedescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcedescriptor(); private: const ::dht::PeerDescriptor& _internal_sourcedescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_sourcedescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcedescriptor(); public: // .dht.PeerDescriptor targetDescriptor = 3; bool has_targetdescriptor() const; void clear_targetdescriptor() ; const ::dht::PeerDescriptor& targetdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_targetdescriptor(); - ::dht::PeerDescriptor* mutable_targetdescriptor(); - void set_allocated_targetdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_targetdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_targetdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_targetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_targetdescriptor(); + void set_allocated_targetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_targetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_targetdescriptor(); private: const ::dht::PeerDescriptor& _internal_targetdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_targetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_targetdescriptor(); public: // .protorpc.RpcMessage rpcMessage = 5; @@ -6424,15 +6564,15 @@ class Message final : public: void clear_rpcmessage() ; const ::protorpc::RpcMessage& rpcmessage() const; - PROTOBUF_NODISCARD ::protorpc::RpcMessage* release_rpcmessage(); - ::protorpc::RpcMessage* mutable_rpcmessage(); - void set_allocated_rpcmessage(::protorpc::RpcMessage* value); - void unsafe_arena_set_allocated_rpcmessage(::protorpc::RpcMessage* value); - ::protorpc::RpcMessage* unsafe_arena_release_rpcmessage(); + [[nodiscard]] ::protorpc::RpcMessage* PROTOBUF_NULLABLE release_rpcmessage(); + ::protorpc::RpcMessage* PROTOBUF_NONNULL mutable_rpcmessage(); + void set_allocated_rpcmessage(::protorpc::RpcMessage* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_rpcmessage(::protorpc::RpcMessage* PROTOBUF_NULLABLE value); + ::protorpc::RpcMessage* PROTOBUF_NULLABLE unsafe_arena_release_rpcmessage(); private: const ::protorpc::RpcMessage& _internal_rpcmessage() const; - ::protorpc::RpcMessage* _internal_mutable_rpcmessage(); + ::protorpc::RpcMessage* PROTOBUF_NONNULL _internal_mutable_rpcmessage(); public: // .dht.ConnectivityRequest connectivityRequest = 6; @@ -6443,15 +6583,15 @@ class Message final : public: void clear_connectivityrequest() ; const ::dht::ConnectivityRequest& connectivityrequest() const; - PROTOBUF_NODISCARD ::dht::ConnectivityRequest* release_connectivityrequest(); - ::dht::ConnectivityRequest* mutable_connectivityrequest(); - void set_allocated_connectivityrequest(::dht::ConnectivityRequest* value); - void unsafe_arena_set_allocated_connectivityrequest(::dht::ConnectivityRequest* value); - ::dht::ConnectivityRequest* unsafe_arena_release_connectivityrequest(); + [[nodiscard]] ::dht::ConnectivityRequest* PROTOBUF_NULLABLE release_connectivityrequest(); + ::dht::ConnectivityRequest* PROTOBUF_NONNULL mutable_connectivityrequest(); + void set_allocated_connectivityrequest(::dht::ConnectivityRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_connectivityrequest(::dht::ConnectivityRequest* PROTOBUF_NULLABLE value); + ::dht::ConnectivityRequest* PROTOBUF_NULLABLE unsafe_arena_release_connectivityrequest(); private: const ::dht::ConnectivityRequest& _internal_connectivityrequest() const; - ::dht::ConnectivityRequest* _internal_mutable_connectivityrequest(); + ::dht::ConnectivityRequest* PROTOBUF_NONNULL _internal_mutable_connectivityrequest(); public: // .dht.ConnectivityResponse connectivityResponse = 7; @@ -6462,15 +6602,15 @@ class Message final : public: void clear_connectivityresponse() ; const ::dht::ConnectivityResponse& connectivityresponse() const; - PROTOBUF_NODISCARD ::dht::ConnectivityResponse* release_connectivityresponse(); - ::dht::ConnectivityResponse* mutable_connectivityresponse(); - void set_allocated_connectivityresponse(::dht::ConnectivityResponse* value); - void unsafe_arena_set_allocated_connectivityresponse(::dht::ConnectivityResponse* value); - ::dht::ConnectivityResponse* unsafe_arena_release_connectivityresponse(); + [[nodiscard]] ::dht::ConnectivityResponse* PROTOBUF_NULLABLE release_connectivityresponse(); + ::dht::ConnectivityResponse* PROTOBUF_NONNULL mutable_connectivityresponse(); + void set_allocated_connectivityresponse(::dht::ConnectivityResponse* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_connectivityresponse(::dht::ConnectivityResponse* PROTOBUF_NULLABLE value); + ::dht::ConnectivityResponse* PROTOBUF_NULLABLE unsafe_arena_release_connectivityresponse(); private: const ::dht::ConnectivityResponse& _internal_connectivityresponse() const; - ::dht::ConnectivityResponse* _internal_mutable_connectivityresponse(); + ::dht::ConnectivityResponse* PROTOBUF_NONNULL _internal_mutable_connectivityresponse(); public: // .dht.HandshakeRequest handshakeRequest = 8; @@ -6481,15 +6621,15 @@ class Message final : public: void clear_handshakerequest() ; const ::dht::HandshakeRequest& handshakerequest() const; - PROTOBUF_NODISCARD ::dht::HandshakeRequest* release_handshakerequest(); - ::dht::HandshakeRequest* mutable_handshakerequest(); - void set_allocated_handshakerequest(::dht::HandshakeRequest* value); - void unsafe_arena_set_allocated_handshakerequest(::dht::HandshakeRequest* value); - ::dht::HandshakeRequest* unsafe_arena_release_handshakerequest(); + [[nodiscard]] ::dht::HandshakeRequest* PROTOBUF_NULLABLE release_handshakerequest(); + ::dht::HandshakeRequest* PROTOBUF_NONNULL mutable_handshakerequest(); + void set_allocated_handshakerequest(::dht::HandshakeRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_handshakerequest(::dht::HandshakeRequest* PROTOBUF_NULLABLE value); + ::dht::HandshakeRequest* PROTOBUF_NULLABLE unsafe_arena_release_handshakerequest(); private: const ::dht::HandshakeRequest& _internal_handshakerequest() const; - ::dht::HandshakeRequest* _internal_mutable_handshakerequest(); + ::dht::HandshakeRequest* PROTOBUF_NONNULL _internal_mutable_handshakerequest(); public: // .dht.HandshakeResponse handshakeResponse = 9; @@ -6500,15 +6640,15 @@ class Message final : public: void clear_handshakeresponse() ; const ::dht::HandshakeResponse& handshakeresponse() const; - PROTOBUF_NODISCARD ::dht::HandshakeResponse* release_handshakeresponse(); - ::dht::HandshakeResponse* mutable_handshakeresponse(); - void set_allocated_handshakeresponse(::dht::HandshakeResponse* value); - void unsafe_arena_set_allocated_handshakeresponse(::dht::HandshakeResponse* value); - ::dht::HandshakeResponse* unsafe_arena_release_handshakeresponse(); + [[nodiscard]] ::dht::HandshakeResponse* PROTOBUF_NULLABLE release_handshakeresponse(); + ::dht::HandshakeResponse* PROTOBUF_NONNULL mutable_handshakeresponse(); + void set_allocated_handshakeresponse(::dht::HandshakeResponse* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_handshakeresponse(::dht::HandshakeResponse* PROTOBUF_NULLABLE value); + ::dht::HandshakeResponse* PROTOBUF_NULLABLE unsafe_arena_release_handshakeresponse(); private: const ::dht::HandshakeResponse& _internal_handshakeresponse() const; - ::dht::HandshakeResponse* _internal_mutable_handshakeresponse(); + ::dht::HandshakeResponse* PROTOBUF_NONNULL _internal_mutable_handshakeresponse(); public: // .dht.RecursiveOperationRequest recursiveOperationRequest = 10; @@ -6519,15 +6659,15 @@ class Message final : public: void clear_recursiveoperationrequest() ; const ::dht::RecursiveOperationRequest& recursiveoperationrequest() const; - PROTOBUF_NODISCARD ::dht::RecursiveOperationRequest* release_recursiveoperationrequest(); - ::dht::RecursiveOperationRequest* mutable_recursiveoperationrequest(); - void set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* value); - void unsafe_arena_set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* value); - ::dht::RecursiveOperationRequest* unsafe_arena_release_recursiveoperationrequest(); + [[nodiscard]] ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE release_recursiveoperationrequest(); + ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL mutable_recursiveoperationrequest(); + void set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE value); + ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE unsafe_arena_release_recursiveoperationrequest(); private: const ::dht::RecursiveOperationRequest& _internal_recursiveoperationrequest() const; - ::dht::RecursiveOperationRequest* _internal_mutable_recursiveoperationrequest(); + ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL _internal_mutable_recursiveoperationrequest(); public: void clear_body(); @@ -6541,9 +6681,13 @@ class Message final : void set_has_handshakerequest(); void set_has_handshakeresponse(); void set_has_recursiveoperationrequest(); - inline bool has_body() const; inline void clear_has_body(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 10, + 8, 46, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6552,63 +6696,66 @@ class Message final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const Message& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr messageid_; ::google::protobuf::internal::ArenaStringPtr serviceid_; - ::dht::PeerDescriptor* sourcedescriptor_; - ::dht::PeerDescriptor* targetdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcedescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE targetdescriptor_; union BodyUnion { constexpr BodyUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::protorpc::RpcMessage* rpcmessage_; - ::dht::ConnectivityRequest* connectivityrequest_; - ::dht::ConnectivityResponse* connectivityresponse_; - ::dht::HandshakeRequest* handshakerequest_; - ::dht::HandshakeResponse* handshakeresponse_; - ::dht::RecursiveOperationRequest* recursiveoperationrequest_; + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE rpcmessage_; + ::google::protobuf::Message* PROTOBUF_NULLABLE connectivityrequest_; + ::google::protobuf::Message* PROTOBUF_NULLABLE connectivityresponse_; + ::google::protobuf::Message* PROTOBUF_NULLABLE handshakerequest_; + ::google::protobuf::Message* PROTOBUF_NULLABLE handshakeresponse_; + ::google::protobuf::Message* PROTOBUF_NULLABLE recursiveoperationrequest_; } body_; ::uint32_t _oneof_case_[1]; - PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class RouteMessageWrapper final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dht.RouteMessageWrapper) */ { +extern const ::google::protobuf::internal::ClassDataFull Message_class_data_; +// ------------------------------------------------------------------- + +class RouteMessageWrapper final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:dht.RouteMessageWrapper) */ { public: inline RouteMessageWrapper() : RouteMessageWrapper(nullptr) {} - ~RouteMessageWrapper() override; - template - explicit PROTOBUF_CONSTEXPR RouteMessageWrapper(::google::protobuf::internal::ConstantInitialized); + ~RouteMessageWrapper() PROTOBUF_FINAL; - inline RouteMessageWrapper(const RouteMessageWrapper& from) - : RouteMessageWrapper(nullptr, from) {} - RouteMessageWrapper(RouteMessageWrapper&& from) noexcept - : RouteMessageWrapper() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RouteMessageWrapper* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RouteMessageWrapper)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RouteMessageWrapper(::google::protobuf::internal::ConstantInitialized); + + inline RouteMessageWrapper(const RouteMessageWrapper& from) : RouteMessageWrapper(nullptr, from) {} + inline RouteMessageWrapper(RouteMessageWrapper&& from) noexcept + : RouteMessageWrapper(nullptr, ::std::move(from)) {} inline RouteMessageWrapper& operator=(const RouteMessageWrapper& from) { CopyFrom(from); return *this; } inline RouteMessageWrapper& operator=(RouteMessageWrapper&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -6620,47 +6767,35 @@ class RouteMessageWrapper final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RouteMessageWrapper& default_instance() { - return *internal_default_instance(); - } - static inline const RouteMessageWrapper* internal_default_instance() { - return reinterpret_cast( - &_RouteMessageWrapper_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(RouteMessageWrapper& a, RouteMessageWrapper& b) { - a.Swap(&b); + return *reinterpret_cast( + &_RouteMessageWrapper_default_instance_); } - inline void Swap(RouteMessageWrapper* other) { + static constexpr int kIndexInFileMessages = 17; + friend void swap(RouteMessageWrapper& a, RouteMessageWrapper& b) { a.Swap(&b); } + inline void Swap(RouteMessageWrapper* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RouteMessageWrapper* other) { + void UnsafeArenaSwap(RouteMessageWrapper* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -6668,33 +6803,40 @@ class RouteMessageWrapper final : // implements Message ---------------------------------------------- - RouteMessageWrapper* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RouteMessageWrapper* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RouteMessageWrapper* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "dht.RouteMessageWrapper"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RouteMessageWrapper* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dht.RouteMessageWrapper"; } + + explicit RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RouteMessageWrapper(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RouteMessageWrapper& from); + RouteMessageWrapper( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RouteMessageWrapper&& from) noexcept + : RouteMessageWrapper(arena) { + *this = ::std::move(from); } - protected: - explicit RouteMessageWrapper(::google::protobuf::Arena* arena); - RouteMessageWrapper(::google::protobuf::Arena* arena, const RouteMessageWrapper& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kReachableThroughFieldNumber = 5, kRoutingPathFieldNumber = 6, @@ -6711,17 +6853,16 @@ class RouteMessageWrapper final : public: void clear_reachablethrough() ; - ::dht::PeerDescriptor* mutable_reachablethrough(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_reachablethrough(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_reachablethrough(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_reachablethrough(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_reachablethrough() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_reachablethrough(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_reachablethrough(); public: const ::dht::PeerDescriptor& reachablethrough(int index) const; - ::dht::PeerDescriptor* add_reachablethrough(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - reachablethrough() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_reachablethrough(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& reachablethrough() const; // repeated .dht.PeerDescriptor routingPath = 6; int routingpath_size() const; private: @@ -6729,17 +6870,16 @@ class RouteMessageWrapper final : public: void clear_routingpath() ; - ::dht::PeerDescriptor* mutable_routingpath(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_routingpath(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_routingpath(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_routingpath(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_routingpath() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_routingpath(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_routingpath(); public: const ::dht::PeerDescriptor& routingpath(int index) const; - ::dht::PeerDescriptor* add_routingpath(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - routingpath() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_routingpath(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& routingpath() const; // repeated string parallelRootNodeIds = 7; int parallelrootnodeids_size() const; private: @@ -6747,92 +6887,89 @@ class RouteMessageWrapper final : public: void clear_parallelrootnodeids() ; - const std::string& parallelrootnodeids(int index) const; - std::string* mutable_parallelrootnodeids(int index); - void set_parallelrootnodeids(int index, const std::string& value); - void set_parallelrootnodeids(int index, std::string&& value); - void set_parallelrootnodeids(int index, const char* value); - void set_parallelrootnodeids(int index, const char* value, std::size_t size); - void set_parallelrootnodeids(int index, absl::string_view value); - std::string* add_parallelrootnodeids(); - void add_parallelrootnodeids(const std::string& value); - void add_parallelrootnodeids(std::string&& value); - void add_parallelrootnodeids(const char* value); - void add_parallelrootnodeids(const char* value, std::size_t size); - void add_parallelrootnodeids(absl::string_view value); - const ::google::protobuf::RepeatedPtrField& parallelrootnodeids() const; - ::google::protobuf::RepeatedPtrField* mutable_parallelrootnodeids(); - - private: - const ::google::protobuf::RepeatedPtrField& _internal_parallelrootnodeids() const; - ::google::protobuf::RepeatedPtrField* _internal_mutable_parallelrootnodeids(); + const ::std::string& parallelrootnodeids(int index) const; + ::std::string* PROTOBUF_NONNULL mutable_parallelrootnodeids(int index); + template + void set_parallelrootnodeids(int index, Arg_&& value, Args_... args); + ::std::string* PROTOBUF_NONNULL add_parallelrootnodeids(); + template + void add_parallelrootnodeids(Arg_&& value, Args_... args); + const ::google::protobuf::RepeatedPtrField<::std::string>& parallelrootnodeids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_parallelrootnodeids(); + + private: + const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_parallelrootnodeids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_parallelrootnodeids(); public: // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // bytes target = 3; void clear_target() ; - const std::string& target() const; - template + const ::std::string& target() const; + template void set_target(Arg_&& arg, Args_... args); - std::string* mutable_target(); - PROTOBUF_NODISCARD std::string* release_target(); - void set_allocated_target(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_target(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_target(); + void set_allocated_target(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_target() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_target( - const std::string& value); - std::string* _internal_mutable_target(); + const ::std::string& _internal_target() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_target(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_target(); public: // .dht.PeerDescriptor sourcePeer = 2; bool has_sourcepeer() const; void clear_sourcepeer() ; const ::dht::PeerDescriptor& sourcepeer() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_sourcepeer(); - ::dht::PeerDescriptor* mutable_sourcepeer(); - void set_allocated_sourcepeer(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_sourcepeer(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_sourcepeer(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_sourcepeer(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_sourcepeer(); + void set_allocated_sourcepeer(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_sourcepeer(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_sourcepeer(); private: const ::dht::PeerDescriptor& _internal_sourcepeer() const; - ::dht::PeerDescriptor* _internal_mutable_sourcepeer(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_sourcepeer(); public: // .dht.Message message = 4; bool has_message() const; void clear_message() ; const ::dht::Message& message() const; - PROTOBUF_NODISCARD ::dht::Message* release_message(); - ::dht::Message* mutable_message(); - void set_allocated_message(::dht::Message* value); - void unsafe_arena_set_allocated_message(::dht::Message* value); - ::dht::Message* unsafe_arena_release_message(); + [[nodiscard]] ::dht::Message* PROTOBUF_NULLABLE release_message(); + ::dht::Message* PROTOBUF_NONNULL mutable_message(); + void set_allocated_message(::dht::Message* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_message(::dht::Message* PROTOBUF_NULLABLE value); + ::dht::Message* PROTOBUF_NULLABLE unsafe_arena_release_message(); private: const ::dht::Message& _internal_message() const; - ::dht::Message* _internal_mutable_message(); + ::dht::Message* PROTOBUF_NONNULL _internal_mutable_message(); public: // @@protoc_insertion_point(class_scope:dht.RouteMessageWrapper) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 4, 60, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -6841,28 +6978,31 @@ class RouteMessageWrapper final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RouteMessageWrapper& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > reachablethrough_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > routingpath_; - ::google::protobuf::RepeatedPtrField parallelrootnodeids_; + ::google::protobuf::RepeatedPtrField<::std::string> parallelrootnodeids_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr target_; - ::dht::PeerDescriptor* sourcepeer_; - ::dht::Message* message_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE sourcepeer_; + ::dht::Message* PROTOBUF_NULLABLE message_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fdht_2fprotos_2fDhtRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull RouteMessageWrapper_class_data_; + // =================================================================== @@ -6881,65 +7021,77 @@ class RouteMessageWrapper final : // bytes key = 1; inline void StoreDataRequest::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& StoreDataRequest::key() const +inline const ::std::string& StoreDataRequest::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.StoreDataRequest.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.StoreDataRequest.key) } -inline std::string* StoreDataRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.key) return _s; } -inline const std::string& StoreDataRequest::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StoreDataRequest::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void StoreDataRequest::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StoreDataRequest::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* StoreDataRequest::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* StoreDataRequest::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StoreDataRequest::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void StoreDataRequest::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.StoreDataRequest.key) } // .google.protobuf.Any data = 2; inline bool StoreDataRequest::has_data() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline const ::google::protobuf::Any& StoreDataRequest::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -6947,76 +7099,78 @@ inline const ::google::protobuf::Any& StoreDataRequest::data() const ABSL_ATTRIB // @@protoc_insertion_point(field_get:dht.StoreDataRequest.data) return _internal_data(); } -inline void StoreDataRequest::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::unsafe_arena_set_allocated_data( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.StoreDataRequest.data) } -inline ::google::protobuf::Any* StoreDataRequest::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE StoreDataRequest::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* released = _impl_.data_; _impl_.data_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* StoreDataRequest::unsafe_arena_release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE StoreDataRequest::unsafe_arena_release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.data) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } -inline ::google::protobuf::Any* StoreDataRequest::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.data_; } -inline ::google::protobuf::Any* StoreDataRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL StoreDataRequest::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.data) return _msg; } -inline void StoreDataRequest::set_allocated_data(::google::protobuf::Any* value) { +inline void StoreDataRequest::set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -7025,65 +7179,77 @@ inline void StoreDataRequest::set_allocated_data(::google::protobuf::Any* value) // bytes creator = 3; inline void StoreDataRequest::clear_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& StoreDataRequest::creator() const +inline const ::std::string& StoreDataRequest::creator() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.StoreDataRequest.creator) return _internal_creator(); } template -inline PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_creator(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StoreDataRequest::set_creator(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.creator_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.StoreDataRequest.creator) } -inline std::string* StoreDataRequest::mutable_creator() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_creator(); +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::mutable_creator() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_creator(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.creator) return _s; } -inline const std::string& StoreDataRequest::_internal_creator() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StoreDataRequest::_internal_creator() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.creator_.Get(); } -inline void StoreDataRequest::_internal_set_creator(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StoreDataRequest::_internal_set_creator(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.Set(value, GetArena()); } -inline std::string* StoreDataRequest::_internal_mutable_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.creator_.Mutable( GetArena()); } -inline std::string* StoreDataRequest::release_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StoreDataRequest::release_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.creator) - return _impl_.creator_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.creator_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.creator_.Set("", GetArena()); + } + return released; } -inline void StoreDataRequest::set_allocated_creator(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::set_allocated_creator(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.creator_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.creator_.IsDefault()) { - _impl_.creator_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.creator_.IsDefault()) { + _impl_.creator_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.StoreDataRequest.creator) } // .google.protobuf.Timestamp createdAt = 4; inline bool StoreDataRequest::has_createdat() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.createdat_ != nullptr); return value; } inline const ::google::protobuf::Timestamp& StoreDataRequest::_internal_createdat() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Timestamp* p = _impl_.createdat_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Timestamp_default_instance_); } @@ -7091,76 +7257,78 @@ inline const ::google::protobuf::Timestamp& StoreDataRequest::createdat() const // @@protoc_insertion_point(field_get:dht.StoreDataRequest.createdAt) return _internal_createdat(); } -inline void StoreDataRequest::unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StoreDataRequest::unsafe_arena_set_allocated_createdat( + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.StoreDataRequest.createdAt) } -inline ::google::protobuf::Timestamp* StoreDataRequest::release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE StoreDataRequest::release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* released = _impl_.createdat_; _impl_.createdat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Timestamp* StoreDataRequest::unsafe_arena_release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE StoreDataRequest::unsafe_arena_release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.StoreDataRequest.createdAt) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* temp = _impl_.createdat_; _impl_.createdat_ = nullptr; return temp; } -inline ::google::protobuf::Timestamp* StoreDataRequest::_internal_mutable_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL StoreDataRequest::_internal_mutable_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena()); _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(p); } return _impl_.createdat_; } -inline ::google::protobuf::Timestamp* StoreDataRequest::mutable_createdat() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL StoreDataRequest::mutable_createdat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* _msg = _internal_mutable_createdat(); // @@protoc_insertion_point(field_mutable:dht.StoreDataRequest.createdAt) return _msg; } -inline void StoreDataRequest::set_allocated_createdat(::google::protobuf::Timestamp* value) { +inline void StoreDataRequest::set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); @@ -7169,8 +7337,10 @@ inline void StoreDataRequest::set_allocated_createdat(::google::protobuf::Timest // uint32 ttl = 5; inline void StoreDataRequest::clear_ttl() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline ::uint32_t StoreDataRequest::ttl() const { // @@protoc_insertion_point(field_get:dht.StoreDataRequest.ttl) @@ -7178,15 +7348,15 @@ inline ::uint32_t StoreDataRequest::ttl() const { } inline void StoreDataRequest::set_ttl(::uint32_t value) { _internal_set_ttl(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:dht.StoreDataRequest.ttl) } inline ::uint32_t StoreDataRequest::_internal_ttl() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ttl_; } inline void StoreDataRequest::_internal_set_ttl(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = value; } @@ -7200,65 +7370,77 @@ inline void StoreDataRequest::_internal_set_ttl(::uint32_t value) { // bytes key = 1; inline void ExternalStoreDataRequest::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ExternalStoreDataRequest::key() const +inline const ::std::string& ExternalStoreDataRequest::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ExternalStoreDataRequest.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void ExternalStoreDataRequest::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ExternalStoreDataRequest::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ExternalStoreDataRequest.key) } -inline std::string* ExternalStoreDataRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL ExternalStoreDataRequest::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.ExternalStoreDataRequest.key) return _s; } -inline const std::string& ExternalStoreDataRequest::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ExternalStoreDataRequest::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void ExternalStoreDataRequest::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ExternalStoreDataRequest::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* ExternalStoreDataRequest::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ExternalStoreDataRequest::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* ExternalStoreDataRequest::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ExternalStoreDataRequest::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ExternalStoreDataRequest.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void ExternalStoreDataRequest::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ExternalStoreDataRequest::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ExternalStoreDataRequest.key) } // .google.protobuf.Any data = 2; inline bool ExternalStoreDataRequest::has_data() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline const ::google::protobuf::Any& ExternalStoreDataRequest::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -7266,76 +7448,78 @@ inline const ::google::protobuf::Any& ExternalStoreDataRequest::data() const ABS // @@protoc_insertion_point(field_get:dht.ExternalStoreDataRequest.data) return _internal_data(); } -inline void ExternalStoreDataRequest::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ExternalStoreDataRequest::unsafe_arena_set_allocated_data( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.ExternalStoreDataRequest.data) } -inline ::google::protobuf::Any* ExternalStoreDataRequest::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE ExternalStoreDataRequest::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::google::protobuf::Any* released = _impl_.data_; _impl_.data_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* ExternalStoreDataRequest::unsafe_arena_release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE ExternalStoreDataRequest::unsafe_arena_release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ExternalStoreDataRequest.data) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::google::protobuf::Any* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } -inline ::google::protobuf::Any* ExternalStoreDataRequest::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL ExternalStoreDataRequest::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.data_; } -inline ::google::protobuf::Any* ExternalStoreDataRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL ExternalStoreDataRequest::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::google::protobuf::Any* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:dht.ExternalStoreDataRequest.data) return _msg; } -inline void ExternalStoreDataRequest::set_allocated_data(::google::protobuf::Any* value) { +inline void ExternalStoreDataRequest::set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -7354,18 +7538,21 @@ inline int ExternalStoreDataResponse::storers_size() const { return _internal_storers_size(); } inline void ExternalStoreDataResponse::clear_storers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.storers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* ExternalStoreDataResponse::mutable_storers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ExternalStoreDataResponse::mutable_storers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ExternalStoreDataResponse.storers) return _internal_mutable_storers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ExternalStoreDataResponse::mutable_storers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ExternalStoreDataResponse::mutable_storers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ExternalStoreDataResponse.storers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_storers(); } inline const ::dht::PeerDescriptor& ExternalStoreDataResponse::storers(int index) const @@ -7373,9 +7560,13 @@ inline const ::dht::PeerDescriptor& ExternalStoreDataResponse::storers(int index // @@protoc_insertion_point(field_get:dht.ExternalStoreDataResponse.storers) return _internal_storers().Get(index); } -inline ::dht::PeerDescriptor* ExternalStoreDataResponse::add_storers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_storers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ExternalStoreDataResponse::add_storers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_storers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ExternalStoreDataResponse.storers) return _add; } @@ -7386,12 +7577,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Extern } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ExternalStoreDataResponse::_internal_storers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.storers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ExternalStoreDataResponse::_internal_mutable_storers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.storers_; } @@ -7401,17 +7592,18 @@ ExternalStoreDataResponse::_internal_mutable_storers() { // .dht.DataEntry entry = 1; inline bool ReplicateDataRequest::has_entry() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); PROTOBUF_ASSUME(!value || _impl_.entry_ != nullptr); return value; } inline void ReplicateDataRequest::clear_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.entry_ != nullptr) _impl_.entry_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline const ::dht::DataEntry& ReplicateDataRequest::_internal_entry() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::DataEntry* p = _impl_.entry_; return p != nullptr ? *p : reinterpret_cast(::dht::_DataEntry_default_instance_); } @@ -7419,76 +7611,78 @@ inline const ::dht::DataEntry& ReplicateDataRequest::entry() const ABSL_ATTRIBUT // @@protoc_insertion_point(field_get:dht.ReplicateDataRequest.entry) return _internal_entry(); } -inline void ReplicateDataRequest::unsafe_arena_set_allocated_entry(::dht::DataEntry* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ReplicateDataRequest::unsafe_arena_set_allocated_entry( + ::dht::DataEntry* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entry_); } _impl_.entry_ = reinterpret_cast<::dht::DataEntry*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.ReplicateDataRequest.entry) } -inline ::dht::DataEntry* ReplicateDataRequest::release_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::DataEntry* PROTOBUF_NULLABLE ReplicateDataRequest::release_entry() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::DataEntry* released = _impl_.entry_; _impl_.entry_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::DataEntry* ReplicateDataRequest::unsafe_arena_release_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::DataEntry* PROTOBUF_NULLABLE ReplicateDataRequest::unsafe_arena_release_entry() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ReplicateDataRequest.entry) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::DataEntry* temp = _impl_.entry_; _impl_.entry_ = nullptr; return temp; } -inline ::dht::DataEntry* ReplicateDataRequest::_internal_mutable_entry() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::DataEntry* PROTOBUF_NONNULL ReplicateDataRequest::_internal_mutable_entry() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.entry_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::DataEntry>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::DataEntry>(GetArena()); _impl_.entry_ = reinterpret_cast<::dht::DataEntry*>(p); } return _impl_.entry_; } -inline ::dht::DataEntry* ReplicateDataRequest::mutable_entry() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::DataEntry* PROTOBUF_NONNULL ReplicateDataRequest::mutable_entry() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::DataEntry* _msg = _internal_mutable_entry(); // @@protoc_insertion_point(field_mutable:dht.ReplicateDataRequest.entry) return _msg; } -inline void ReplicateDataRequest::set_allocated_entry(::dht::DataEntry* value) { +inline void ReplicateDataRequest::set_allocated_entry(::dht::DataEntry* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::DataEntry*>(_impl_.entry_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entry_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::DataEntry*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.entry_ = reinterpret_cast<::dht::DataEntry*>(value); @@ -7501,65 +7695,77 @@ inline void ReplicateDataRequest::set_allocated_entry(::dht::DataEntry* value) { // bytes key = 1; inline void DataEntry::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& DataEntry::key() const +inline const ::std::string& DataEntry::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.DataEntry.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void DataEntry::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void DataEntry::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.DataEntry.key) } -inline std::string* DataEntry::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL DataEntry::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.key) return _s; } -inline const std::string& DataEntry::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& DataEntry::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void DataEntry::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void DataEntry::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* DataEntry::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL DataEntry::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* DataEntry::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE DataEntry::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void DataEntry::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.DataEntry.key) } // .google.protobuf.Any data = 2; inline bool DataEntry::has_data() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline const ::google::protobuf::Any& DataEntry::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -7567,76 +7773,78 @@ inline const ::google::protobuf::Any& DataEntry::data() const ABSL_ATTRIBUTE_LIF // @@protoc_insertion_point(field_get:dht.DataEntry.data) return _internal_data(); } -inline void DataEntry::unsafe_arena_set_allocated_data(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::unsafe_arena_set_allocated_data( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.DataEntry.data) } -inline ::google::protobuf::Any* DataEntry::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE DataEntry::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* released = _impl_.data_; _impl_.data_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* DataEntry::unsafe_arena_release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE DataEntry::unsafe_arena_release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.data) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } -inline ::google::protobuf::Any* DataEntry::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL DataEntry::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.data_; } -inline ::google::protobuf::Any* DataEntry::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL DataEntry::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::google::protobuf::Any* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.data) return _msg; } -inline void DataEntry::set_allocated_data(::google::protobuf::Any* value) { +inline void DataEntry::set_allocated_data(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.data_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -7645,65 +7853,77 @@ inline void DataEntry::set_allocated_data(::google::protobuf::Any* value) { // bytes creator = 3; inline void DataEntry::clear_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& DataEntry::creator() const +inline const ::std::string& DataEntry::creator() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.DataEntry.creator) return _internal_creator(); } template -inline PROTOBUF_ALWAYS_INLINE void DataEntry::set_creator(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void DataEntry::set_creator(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.creator_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.DataEntry.creator) } -inline std::string* DataEntry::mutable_creator() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_creator(); +inline ::std::string* PROTOBUF_NONNULL DataEntry::mutable_creator() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_creator(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.creator) return _s; } -inline const std::string& DataEntry::_internal_creator() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& DataEntry::_internal_creator() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.creator_.Get(); } -inline void DataEntry::_internal_set_creator(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void DataEntry::_internal_set_creator(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.creator_.Set(value, GetArena()); } -inline std::string* DataEntry::_internal_mutable_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL DataEntry::_internal_mutable_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.creator_.Mutable( GetArena()); } -inline std::string* DataEntry::release_creator() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE DataEntry::release_creator() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.creator) - return _impl_.creator_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.creator_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.creator_.Set("", GetArena()); + } + return released; } -inline void DataEntry::set_allocated_creator(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::set_allocated_creator(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.creator_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.creator_.IsDefault()) { - _impl_.creator_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.creator_.IsDefault()) { + _impl_.creator_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.DataEntry.creator) } // .google.protobuf.Timestamp createdAt = 4; inline bool DataEntry::has_createdat() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.createdat_ != nullptr); return value; } inline const ::google::protobuf::Timestamp& DataEntry::_internal_createdat() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Timestamp* p = _impl_.createdat_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Timestamp_default_instance_); } @@ -7711,76 +7931,78 @@ inline const ::google::protobuf::Timestamp& DataEntry::createdat() const ABSL_AT // @@protoc_insertion_point(field_get:dht.DataEntry.createdAt) return _internal_createdat(); } -inline void DataEntry::unsafe_arena_set_allocated_createdat(::google::protobuf::Timestamp* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::unsafe_arena_set_allocated_createdat( + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.DataEntry.createdAt) } -inline ::google::protobuf::Timestamp* DataEntry::release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* released = _impl_.createdat_; _impl_.createdat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Timestamp* DataEntry::unsafe_arena_release_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::unsafe_arena_release_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.createdAt) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* temp = _impl_.createdat_; _impl_.createdat_ = nullptr; return temp; } -inline ::google::protobuf::Timestamp* DataEntry::_internal_mutable_createdat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::_internal_mutable_createdat() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.createdat_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena()); _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(p); } return _impl_.createdat_; } -inline ::google::protobuf::Timestamp* DataEntry::mutable_createdat() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::mutable_createdat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::google::protobuf::Timestamp* _msg = _internal_mutable_createdat(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.createdAt) return _msg; } -inline void DataEntry::set_allocated_createdat(::google::protobuf::Timestamp* value) { +inline void DataEntry::set_allocated_createdat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.createdat_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.createdat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); @@ -7789,12 +8011,12 @@ inline void DataEntry::set_allocated_createdat(::google::protobuf::Timestamp* va // .google.protobuf.Timestamp storedAt = 5; inline bool DataEntry::has_storedat() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.storedat_ != nullptr); return value; } inline const ::google::protobuf::Timestamp& DataEntry::_internal_storedat() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Timestamp* p = _impl_.storedat_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Timestamp_default_instance_); } @@ -7802,76 +8024,78 @@ inline const ::google::protobuf::Timestamp& DataEntry::storedat() const ABSL_ATT // @@protoc_insertion_point(field_get:dht.DataEntry.storedAt) return _internal_storedat(); } -inline void DataEntry::unsafe_arena_set_allocated_storedat(::google::protobuf::Timestamp* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void DataEntry::unsafe_arena_set_allocated_storedat( + ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.storedat_); } _impl_.storedat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.DataEntry.storedAt) } -inline ::google::protobuf::Timestamp* DataEntry::release_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::release_storedat() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Timestamp* released = _impl_.storedat_; _impl_.storedat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Timestamp* DataEntry::unsafe_arena_release_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE DataEntry::unsafe_arena_release_storedat() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.DataEntry.storedAt) - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Timestamp* temp = _impl_.storedat_; _impl_.storedat_ = nullptr; return temp; } -inline ::google::protobuf::Timestamp* DataEntry::_internal_mutable_storedat() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::_internal_mutable_storedat() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.storedat_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena()); _impl_.storedat_ = reinterpret_cast<::google::protobuf::Timestamp*>(p); } return _impl_.storedat_; } -inline ::google::protobuf::Timestamp* DataEntry::mutable_storedat() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL DataEntry::mutable_storedat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Timestamp* _msg = _internal_mutable_storedat(); // @@protoc_insertion_point(field_mutable:dht.DataEntry.storedAt) return _msg; } -inline void DataEntry::set_allocated_storedat(::google::protobuf::Timestamp* value) { +inline void DataEntry::set_allocated_storedat(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.storedat_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.storedat_ = reinterpret_cast<::google::protobuf::Timestamp*>(value); @@ -7880,8 +8104,10 @@ inline void DataEntry::set_allocated_storedat(::google::protobuf::Timestamp* val // uint32 ttl = 6; inline void DataEntry::clear_ttl() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline ::uint32_t DataEntry::ttl() const { // @@protoc_insertion_point(field_get:dht.DataEntry.ttl) @@ -7889,22 +8115,24 @@ inline ::uint32_t DataEntry::ttl() const { } inline void DataEntry::set_ttl(::uint32_t value) { _internal_set_ttl(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:dht.DataEntry.ttl) } inline ::uint32_t DataEntry::_internal_ttl() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ttl_; } inline void DataEntry::_internal_set_ttl(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ttl_ = value; } // bool stale = 7; inline void DataEntry::clear_stale() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stale_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline bool DataEntry::stale() const { // @@protoc_insertion_point(field_get:dht.DataEntry.stale) @@ -7912,22 +8140,24 @@ inline bool DataEntry::stale() const { } inline void DataEntry::set_stale(bool value) { _internal_set_stale(value); + SetHasBit(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_set:dht.DataEntry.stale) } inline bool DataEntry::_internal_stale() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.stale_; } inline void DataEntry::_internal_set_stale(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stale_ = value; } // bool deleted = 8; inline void DataEntry::clear_deleted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.deleted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000080U); } inline bool DataEntry::deleted() const { // @@protoc_insertion_point(field_get:dht.DataEntry.deleted) @@ -7935,15 +8165,15 @@ inline bool DataEntry::deleted() const { } inline void DataEntry::set_deleted(bool value) { _internal_set_deleted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000080U); // @@protoc_insertion_point(field_set:dht.DataEntry.deleted) } inline bool DataEntry::_internal_deleted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.deleted_; } inline void DataEntry::_internal_set_deleted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.deleted_ = value; } @@ -7953,107 +8183,131 @@ inline void DataEntry::_internal_set_deleted(bool value) { // bytes nodeId = 1; inline void ClosestPeersRequest::clear_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ClosestPeersRequest::nodeid() const +inline const ::std::string& ClosestPeersRequest::nodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestPeersRequest.nodeId) return _internal_nodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_nodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_nodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.nodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestPeersRequest.nodeId) } -inline std::string* ClosestPeersRequest::mutable_nodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nodeid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::mutable_nodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_nodeid(); // @@protoc_insertion_point(field_mutable:dht.ClosestPeersRequest.nodeId) return _s; } -inline const std::string& ClosestPeersRequest::_internal_nodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersRequest::_internal_nodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nodeid_.Get(); } -inline void ClosestPeersRequest::_internal_set_nodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersRequest::_internal_set_nodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.Set(value, GetArena()); } -inline std::string* ClosestPeersRequest::_internal_mutable_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::_internal_mutable_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nodeid_.Mutable( GetArena()); } -inline std::string* ClosestPeersRequest::release_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersRequest::release_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestPeersRequest.nodeId) - return _impl_.nodeid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.nodeid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nodeid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersRequest::set_allocated_nodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersRequest::set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.nodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nodeid_.IsDefault()) { - _impl_.nodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nodeid_.IsDefault()) { + _impl_.nodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestPeersRequest.nodeId) } // string requestId = 2; inline void ClosestPeersRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestPeersRequest::requestid() const +inline const ::std::string& ClosestPeersRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestPeersRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestPeersRequest.requestId) } -inline std::string* ClosestPeersRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestPeersRequest.requestId) return _s; } -inline const std::string& ClosestPeersRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestPeersRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestPeersRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestPeersRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestPeersRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestPeersRequest.requestId) } @@ -8069,18 +8323,21 @@ inline int ClosestPeersResponse::peers_size() const { return _internal_peers_size(); } inline void ClosestPeersResponse::clear_peers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.peers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* ClosestPeersResponse::mutable_peers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersResponse::mutable_peers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ClosestPeersResponse.peers) return _internal_mutable_peers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ClosestPeersResponse::mutable_peers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestPeersResponse::mutable_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ClosestPeersResponse.peers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_peers(); } inline const ::dht::PeerDescriptor& ClosestPeersResponse::peers(int index) const @@ -8088,9 +8345,13 @@ inline const ::dht::PeerDescriptor& ClosestPeersResponse::peers(int index) const // @@protoc_insertion_point(field_get:dht.ClosestPeersResponse.peers) return _internal_peers().Get(index); } -inline ::dht::PeerDescriptor* ClosestPeersResponse::add_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_peers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestPeersResponse::add_peers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_peers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ClosestPeersResponse.peers) return _add; } @@ -8101,65 +8362,77 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Closes } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ClosestPeersResponse::_internal_peers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.peers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestPeersResponse::_internal_mutable_peers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.peers_; } // string requestId = 2; inline void ClosestPeersResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestPeersResponse::requestid() const +inline const ::std::string& ClosestPeersResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestPeersResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestPeersResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestPeersResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestPeersResponse.requestId) } -inline std::string* ClosestPeersResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestPeersResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestPeersResponse.requestId) return _s; } -inline const std::string& ClosestPeersResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestPeersResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestPeersResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestPeersResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestPeersResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestPeersResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestPeersResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestPeersResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestPeersResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestPeersResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestPeersResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestPeersResponse.requestId) } @@ -8169,107 +8442,131 @@ inline void ClosestPeersResponse::set_allocated_requestid(std::string* value) { // bytes ringId = 1; inline void ClosestRingPeersRequest::clear_ringid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ringid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ClosestRingPeersRequest::ringid() const +inline const ::std::string& ClosestRingPeersRequest::ringid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestRingPeersRequest.ringId) return _internal_ringid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_ringid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_ringid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.ringid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestRingPeersRequest.ringId) } -inline std::string* ClosestRingPeersRequest::mutable_ringid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_ringid(); +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::mutable_ringid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_ringid(); // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersRequest.ringId) return _s; } -inline const std::string& ClosestRingPeersRequest::_internal_ringid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestRingPeersRequest::_internal_ringid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ringid_.Get(); } -inline void ClosestRingPeersRequest::_internal_set_ringid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestRingPeersRequest::_internal_set_ringid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ringid_.Set(value, GetArena()); } -inline std::string* ClosestRingPeersRequest::_internal_mutable_ringid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::_internal_mutable_ringid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.ringid_.Mutable( GetArena()); } -inline std::string* ClosestRingPeersRequest::release_ringid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestRingPeersRequest::release_ringid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestRingPeersRequest.ringId) - return _impl_.ringid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.ringid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.ringid_.Set("", GetArena()); + } + return released; } -inline void ClosestRingPeersRequest::set_allocated_ringid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestRingPeersRequest::set_allocated_ringid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.ringid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ringid_.IsDefault()) { - _impl_.ringid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.ringid_.IsDefault()) { + _impl_.ringid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestRingPeersRequest.ringId) } // string requestId = 2; inline void ClosestRingPeersRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ClosestRingPeersRequest::requestid() const +inline const ::std::string& ClosestRingPeersRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestRingPeersRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestRingPeersRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestRingPeersRequest.requestId) } -inline std::string* ClosestRingPeersRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersRequest.requestId) return _s; } -inline const std::string& ClosestRingPeersRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestRingPeersRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestRingPeersRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestRingPeersRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestRingPeersRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestRingPeersRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestRingPeersRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestRingPeersRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestRingPeersRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestRingPeersRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestRingPeersRequest.requestId) } @@ -8285,18 +8582,21 @@ inline int ClosestRingPeersResponse::leftpeers_size() const { return _internal_leftpeers_size(); } inline void ClosestRingPeersResponse::clear_leftpeers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.leftpeers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::mutable_leftpeers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_leftpeers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersResponse.leftPeers) return _internal_mutable_leftpeers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ClosestRingPeersResponse::mutable_leftpeers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_leftpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ClosestRingPeersResponse.leftPeers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_leftpeers(); } inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::leftpeers(int index) const @@ -8304,9 +8604,13 @@ inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::leftpeers(int inde // @@protoc_insertion_point(field_get:dht.ClosestRingPeersResponse.leftPeers) return _internal_leftpeers().Get(index); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::add_leftpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_leftpeers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::add_leftpeers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_leftpeers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ClosestRingPeersResponse.leftPeers) return _add; } @@ -8317,12 +8621,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Closes } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ClosestRingPeersResponse::_internal_leftpeers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.leftpeers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::_internal_mutable_leftpeers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.leftpeers_; } @@ -8334,18 +8638,21 @@ inline int ClosestRingPeersResponse::rightpeers_size() const { return _internal_rightpeers_size(); } inline void ClosestRingPeersResponse::clear_rightpeers() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rightpeers_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::mutable_rightpeers(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_rightpeers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersResponse.rightPeers) return _internal_mutable_rightpeers()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ClosestRingPeersResponse::mutable_rightpeers() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_rightpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:dht.ClosestRingPeersResponse.rightPeers) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_rightpeers(); } inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::rightpeers(int index) const @@ -8353,9 +8660,13 @@ inline const ::dht::PeerDescriptor& ClosestRingPeersResponse::rightpeers(int ind // @@protoc_insertion_point(field_get:dht.ClosestRingPeersResponse.rightPeers) return _internal_rightpeers().Get(index); } -inline ::dht::PeerDescriptor* ClosestRingPeersResponse::add_rightpeers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_rightpeers()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ClosestRingPeersResponse::add_rightpeers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_rightpeers()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:dht.ClosestRingPeersResponse.rightPeers) return _add; } @@ -8366,65 +8677,77 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Closes } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ClosestRingPeersResponse::_internal_rightpeers() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rightpeers_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ClosestRingPeersResponse::_internal_mutable_rightpeers() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.rightpeers_; } // string requestId = 3; inline void ClosestRingPeersResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& ClosestRingPeersResponse::requestid() const +inline const ::std::string& ClosestRingPeersResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ClosestRingPeersResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void ClosestRingPeersResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ClosestRingPeersResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ClosestRingPeersResponse.requestId) } -inline std::string* ClosestRingPeersResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.ClosestRingPeersResponse.requestId) return _s; } -inline const std::string& ClosestRingPeersResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ClosestRingPeersResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void ClosestRingPeersResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ClosestRingPeersResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* ClosestRingPeersResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ClosestRingPeersResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* ClosestRingPeersResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ClosestRingPeersResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ClosestRingPeersResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void ClosestRingPeersResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ClosestRingPeersResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ClosestRingPeersResponse.requestId) } @@ -8434,61 +8757,75 @@ inline void ClosestRingPeersResponse::set_allocated_requestid(std::string* value // string sessionId = 1; inline void RecursiveOperationRequest::clear_sessionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sessionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RecursiveOperationRequest::sessionid() const +inline const ::std::string& RecursiveOperationRequest::sessionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RecursiveOperationRequest.sessionId) return _internal_sessionid(); } template -inline PROTOBUF_ALWAYS_INLINE void RecursiveOperationRequest::set_sessionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RecursiveOperationRequest::set_sessionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.sessionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RecursiveOperationRequest.sessionId) } -inline std::string* RecursiveOperationRequest::mutable_sessionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_sessionid(); +inline ::std::string* PROTOBUF_NONNULL RecursiveOperationRequest::mutable_sessionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_sessionid(); // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationRequest.sessionId) return _s; } -inline const std::string& RecursiveOperationRequest::_internal_sessionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RecursiveOperationRequest::_internal_sessionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.sessionid_.Get(); } -inline void RecursiveOperationRequest::_internal_set_sessionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RecursiveOperationRequest::_internal_set_sessionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sessionid_.Set(value, GetArena()); } -inline std::string* RecursiveOperationRequest::_internal_mutable_sessionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RecursiveOperationRequest::_internal_mutable_sessionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.sessionid_.Mutable( GetArena()); } -inline std::string* RecursiveOperationRequest::release_sessionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RecursiveOperationRequest::release_sessionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RecursiveOperationRequest.sessionId) - return _impl_.sessionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.sessionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.sessionid_.Set("", GetArena()); + } + return released; } -inline void RecursiveOperationRequest::set_allocated_sessionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RecursiveOperationRequest::set_allocated_sessionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.sessionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sessionid_.IsDefault()) { - _impl_.sessionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.sessionid_.IsDefault()) { + _impl_.sessionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RecursiveOperationRequest.sessionId) } // .dht.RecursiveOperation operation = 2; inline void RecursiveOperationRequest::clear_operation() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.operation_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::dht::RecursiveOperation RecursiveOperationRequest::operation() const { // @@protoc_insertion_point(field_get:dht.RecursiveOperationRequest.operation) @@ -8496,15 +8833,15 @@ inline ::dht::RecursiveOperation RecursiveOperationRequest::operation() const { } inline void RecursiveOperationRequest::set_operation(::dht::RecursiveOperation value) { _internal_set_operation(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.RecursiveOperationRequest.operation) } inline ::dht::RecursiveOperation RecursiveOperationRequest::_internal_operation() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::RecursiveOperation>(_impl_.operation_); } inline void RecursiveOperationRequest::_internal_set_operation(::dht::RecursiveOperation value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.operation_ = value; } @@ -8520,18 +8857,21 @@ inline int RecursiveOperationResponse::closestconnectednodes_size() const { return _internal_closestconnectednodes_size(); } inline void RecursiveOperationResponse::clear_closestconnectednodes() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.closestconnectednodes_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::mutable_closestconnectednodes(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_closestconnectednodes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationResponse.closestConnectedNodes) return _internal_mutable_closestconnectednodes()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RecursiveOperationResponse::mutable_closestconnectednodes() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_closestconnectednodes() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.RecursiveOperationResponse.closestConnectedNodes) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_closestconnectednodes(); } inline const ::dht::PeerDescriptor& RecursiveOperationResponse::closestconnectednodes(int index) const @@ -8539,9 +8879,13 @@ inline const ::dht::PeerDescriptor& RecursiveOperationResponse::closestconnected // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.closestConnectedNodes) return _internal_closestconnectednodes().Get(index); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::add_closestconnectednodes() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_closestconnectednodes()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::add_closestconnectednodes() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_closestconnectednodes()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.RecursiveOperationResponse.closestConnectedNodes) return _add; } @@ -8552,12 +8896,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Recurs } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RecursiveOperationResponse::_internal_closestconnectednodes() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.closestconnectednodes_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::_internal_mutable_closestconnectednodes() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.closestconnectednodes_; } @@ -8569,18 +8913,21 @@ inline int RecursiveOperationResponse::dataentries_size() const { return _internal_dataentries_size(); } inline void RecursiveOperationResponse::clear_dataentries() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dataentries_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -inline ::dht::DataEntry* RecursiveOperationResponse::mutable_dataentries(int index) +inline ::dht::DataEntry* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_dataentries(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationResponse.dataEntries) return _internal_mutable_dataentries()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* RecursiveOperationResponse::mutable_dataentries() +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_dataentries() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:dht.RecursiveOperationResponse.dataEntries) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_dataentries(); } inline const ::dht::DataEntry& RecursiveOperationResponse::dataentries(int index) const @@ -8588,9 +8935,13 @@ inline const ::dht::DataEntry& RecursiveOperationResponse::dataentries(int index // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.dataEntries) return _internal_dataentries().Get(index); } -inline ::dht::DataEntry* RecursiveOperationResponse::add_dataentries() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::DataEntry* _add = _internal_mutable_dataentries()->Add(); +inline ::dht::DataEntry* PROTOBUF_NONNULL RecursiveOperationResponse::add_dataentries() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::DataEntry* _add = + _internal_mutable_dataentries()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:dht.RecursiveOperationResponse.dataEntries) return _add; } @@ -8601,19 +8952,21 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& RecursiveOp } inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& RecursiveOperationResponse::_internal_dataentries() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.dataentries_; } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL RecursiveOperationResponse::_internal_mutable_dataentries() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.dataentries_; } // bool noCloserNodesFound = 3; inline void RecursiveOperationResponse::clear_noclosernodesfound() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.noclosernodesfound_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline bool RecursiveOperationResponse::noclosernodesfound() const { // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.noCloserNodesFound) @@ -8621,15 +8974,15 @@ inline bool RecursiveOperationResponse::noclosernodesfound() const { } inline void RecursiveOperationResponse::set_noclosernodesfound(bool value) { _internal_set_noclosernodesfound(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:dht.RecursiveOperationResponse.noCloserNodesFound) } inline bool RecursiveOperationResponse::_internal_noclosernodesfound() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.noclosernodesfound_; } inline void RecursiveOperationResponse::_internal_set_noclosernodesfound(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.noclosernodesfound_ = value; } @@ -8641,18 +8994,21 @@ inline int RecursiveOperationResponse::routingpath_size() const { return _internal_routingpath_size(); } inline void RecursiveOperationResponse::clear_routingpath() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.routingpath_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000004U); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::mutable_routingpath(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_routingpath(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RecursiveOperationResponse.routingPath) return _internal_mutable_routingpath()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RecursiveOperationResponse::mutable_routingpath() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::mutable_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_mutable_list:dht.RecursiveOperationResponse.routingPath) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_routingpath(); } inline const ::dht::PeerDescriptor& RecursiveOperationResponse::routingpath(int index) const @@ -8660,9 +9016,13 @@ inline const ::dht::PeerDescriptor& RecursiveOperationResponse::routingpath(int // @@protoc_insertion_point(field_get:dht.RecursiveOperationResponse.routingPath) return _internal_routingpath().Get(index); } -inline ::dht::PeerDescriptor* RecursiveOperationResponse::add_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_routingpath()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RecursiveOperationResponse::add_routingpath() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_routingpath()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_add:dht.RecursiveOperationResponse.routingPath) return _add; } @@ -8673,12 +9033,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Recurs } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RecursiveOperationResponse::_internal_routingpath() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.routingpath_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RecursiveOperationResponse::_internal_mutable_routingpath() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.routingpath_; } @@ -8688,54 +9048,66 @@ RecursiveOperationResponse::_internal_mutable_routingpath() { // string requestId = 1; inline void PingRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PingRequest::requestid() const +inline const ::std::string& PingRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PingRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void PingRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PingRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PingRequest.requestId) } -inline std::string* PingRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL PingRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.PingRequest.requestId) return _s; } -inline const std::string& PingRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PingRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void PingRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PingRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* PingRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PingRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* PingRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PingRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PingRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void PingRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PingRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PingRequest.requestId) } @@ -8745,54 +9117,66 @@ inline void PingRequest::set_allocated_requestid(std::string* value) { // string requestId = 1; inline void PingResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PingResponse::requestid() const +inline const ::std::string& PingResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PingResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void PingResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PingResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PingResponse.requestId) } -inline std::string* PingResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL PingResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.PingResponse.requestId) return _s; } -inline const std::string& PingResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PingResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void PingResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PingResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* PingResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PingResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* PingResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PingResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PingResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void PingResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PingResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PingResponse.requestId) } @@ -8806,61 +9190,75 @@ inline void PingResponse::set_allocated_requestid(std::string* value) { // bytes nodeId = 1; inline void PeerDescriptor::clear_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& PeerDescriptor::nodeid() const +inline const ::std::string& PeerDescriptor::nodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.nodeId) return _internal_nodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_nodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_nodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.nodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.nodeId) } -inline std::string* PeerDescriptor::mutable_nodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nodeid(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_nodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_nodeid(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.nodeId) return _s; } -inline const std::string& PeerDescriptor::_internal_nodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_nodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nodeid_.Get(); } -inline void PeerDescriptor::_internal_set_nodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void PeerDescriptor::_internal_set_nodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodeid_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nodeid_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_nodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_nodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.nodeId) - return _impl_.nodeid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.nodeid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nodeid_.Set("", GetArena()); + } + return released; } -inline void PeerDescriptor::set_allocated_nodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_nodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.nodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nodeid_.IsDefault()) { - _impl_.nodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nodeid_.IsDefault()) { + _impl_.nodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PeerDescriptor.nodeId) } // .dht.NodeType type = 2; inline void PeerDescriptor::clear_type() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline ::dht::NodeType PeerDescriptor::type() const { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.type) @@ -8868,31 +9266,32 @@ inline ::dht::NodeType PeerDescriptor::type() const { } inline void PeerDescriptor::set_type(::dht::NodeType value) { _internal_set_type(value); + SetHasBit(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.type) } inline ::dht::NodeType PeerDescriptor::_internal_type() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::NodeType>(_impl_.type_); } inline void PeerDescriptor::_internal_set_type(::dht::NodeType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = value; } // .dht.ConnectivityMethod udp = 3; inline bool PeerDescriptor::has_udp() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.udp_ != nullptr); return value; } inline void PeerDescriptor::clear_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.udp_ != nullptr) _impl_.udp_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::dht::ConnectivityMethod& PeerDescriptor::_internal_udp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.udp_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -8900,76 +9299,78 @@ inline const ::dht::ConnectivityMethod& PeerDescriptor::udp() const ABSL_ATTRIBU // @@protoc_insertion_point(field_get:dht.PeerDescriptor.udp) return _internal_udp(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_udp(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_udp( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.udp_); } _impl_.udp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.PeerDescriptor.udp) } -inline ::dht::ConnectivityMethod* PeerDescriptor::release_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* released = _impl_.udp_; _impl_.udp_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.udp) - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* temp = _impl_.udp_; _impl_.udp_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* PeerDescriptor::_internal_mutable_udp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_udp() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.udp_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.udp_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.udp_; } -inline ::dht::ConnectivityMethod* PeerDescriptor::mutable_udp() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_udp() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* _msg = _internal_mutable_udp(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.udp) return _msg; } -inline void PeerDescriptor::set_allocated_udp(::dht::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_udp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.udp_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.udp_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.udp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -8978,17 +9379,18 @@ inline void PeerDescriptor::set_allocated_udp(::dht::ConnectivityMethod* value) // .dht.ConnectivityMethod tcp = 4; inline bool PeerDescriptor::has_tcp() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.tcp_ != nullptr); return value; } inline void PeerDescriptor::clear_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.tcp_ != nullptr) _impl_.tcp_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline const ::dht::ConnectivityMethod& PeerDescriptor::_internal_tcp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.tcp_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -8996,76 +9398,78 @@ inline const ::dht::ConnectivityMethod& PeerDescriptor::tcp() const ABSL_ATTRIBU // @@protoc_insertion_point(field_get:dht.PeerDescriptor.tcp) return _internal_tcp(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_tcp(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_tcp( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tcp_); } _impl_.tcp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.PeerDescriptor.tcp) } -inline ::dht::ConnectivityMethod* PeerDescriptor::release_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::dht::ConnectivityMethod* released = _impl_.tcp_; _impl_.tcp_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.tcp) - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::dht::ConnectivityMethod* temp = _impl_.tcp_; _impl_.tcp_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* PeerDescriptor::_internal_mutable_tcp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000008u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_tcp() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.tcp_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.tcp_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.tcp_; } -inline ::dht::ConnectivityMethod* PeerDescriptor::mutable_tcp() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_tcp() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::dht::ConnectivityMethod* _msg = _internal_mutable_tcp(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.tcp) return _msg; } -inline void PeerDescriptor::set_allocated_tcp(::dht::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_tcp(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.tcp_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tcp_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.tcp_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -9074,17 +9478,18 @@ inline void PeerDescriptor::set_allocated_tcp(::dht::ConnectivityMethod* value) // .dht.ConnectivityMethod websocket = 5; inline bool PeerDescriptor::has_websocket() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); PROTOBUF_ASSUME(!value || _impl_.websocket_ != nullptr); return value; } inline void PeerDescriptor::clear_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ != nullptr) _impl_.websocket_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline const ::dht::ConnectivityMethod& PeerDescriptor::_internal_websocket() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.websocket_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -9092,76 +9497,78 @@ inline const ::dht::ConnectivityMethod& PeerDescriptor::websocket() const ABSL_A // @@protoc_insertion_point(field_get:dht.PeerDescriptor.websocket) return _internal_websocket(); } -inline void PeerDescriptor::unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::unsafe_arena_set_allocated_websocket( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.PeerDescriptor.websocket) } -inline ::dht::ConnectivityMethod* PeerDescriptor::release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::ConnectivityMethod* released = _impl_.websocket_; _impl_.websocket_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* PeerDescriptor::unsafe_arena_release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE PeerDescriptor::unsafe_arena_release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.websocket) - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::ConnectivityMethod* temp = _impl_.websocket_; _impl_.websocket_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* PeerDescriptor::_internal_mutable_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000010u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.websocket_; } -inline ::dht::ConnectivityMethod* PeerDescriptor::mutable_websocket() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL PeerDescriptor::mutable_websocket() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::ConnectivityMethod* _msg = _internal_mutable_websocket(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.websocket) return _msg; } -inline void PeerDescriptor::set_allocated_websocket(::dht::ConnectivityMethod* value) { +inline void PeerDescriptor::set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.websocket_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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] |= 0x00000010u; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -9170,13 +9577,14 @@ inline void PeerDescriptor::set_allocated_websocket(::dht::ConnectivityMethod* v // optional uint32 region = 6; inline bool PeerDescriptor::has_region() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U); return value; } inline void PeerDescriptor::clear_region() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.region_ = 0u; - _impl_._has_bits_[0] &= ~0x00000020u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000080U); } inline ::uint32_t PeerDescriptor::region() const { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.region) @@ -9184,27 +9592,28 @@ inline ::uint32_t PeerDescriptor::region() const { } inline void PeerDescriptor::set_region(::uint32_t value) { _internal_set_region(value); + SetHasBit(_impl_._has_bits_[0], 0x00000080U); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.region) } inline ::uint32_t PeerDescriptor::_internal_region() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.region_; } inline void PeerDescriptor::_internal_set_region(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000020u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.region_ = value; } // optional uint32 ipAddress = 7; inline bool PeerDescriptor::has_ipaddress() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U); return value; } inline void PeerDescriptor::clear_ipaddress() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000100U); } inline ::uint32_t PeerDescriptor::ipaddress() const { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.ipAddress) @@ -9212,157 +9621,153 @@ inline ::uint32_t PeerDescriptor::ipaddress() const { } inline void PeerDescriptor::set_ipaddress(::uint32_t value) { _internal_set_ipaddress(value); + SetHasBit(_impl_._has_bits_[0], 0x00000100U); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.ipAddress) } inline ::uint32_t PeerDescriptor::_internal_ipaddress() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ipaddress_; } inline void PeerDescriptor::_internal_set_ipaddress(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000040u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = value; } // optional bytes publicKey = 8; inline bool PeerDescriptor::has_publickey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void PeerDescriptor::clear_publickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.publickey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& PeerDescriptor::publickey() const +inline const ::std::string& PeerDescriptor::publickey() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.publicKey) return _internal_publickey(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_publickey(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_publickey(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.publickey_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.publicKey) } -inline std::string* PeerDescriptor::mutable_publickey() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_publickey(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_publickey() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_publickey(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.publicKey) return _s; } -inline const std::string& PeerDescriptor::_internal_publickey() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_publickey() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.publickey_.Get(); } -inline void PeerDescriptor::_internal_set_publickey(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void PeerDescriptor::_internal_set_publickey(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.publickey_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_publickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_publickey() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.publickey_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_publickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_publickey() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.publicKey) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); auto* released = _impl_.publickey_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.publickey_.Set("", GetArena()); + } return released; } -inline void PeerDescriptor::set_allocated_publickey(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_publickey(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.publickey_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PeerDescriptor.publicKey) } // optional bytes signature = 9; inline bool PeerDescriptor::has_signature() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void PeerDescriptor::clear_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& PeerDescriptor::signature() const +inline const ::std::string& PeerDescriptor::signature() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.PeerDescriptor.signature) return _internal_signature(); } template -inline PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_signature(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +PROTOBUF_ALWAYS_INLINE void PeerDescriptor::set_signature(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.signature_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.PeerDescriptor.signature) } -inline std::string* PeerDescriptor::mutable_signature() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_signature(); +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::mutable_signature() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_signature(); // @@protoc_insertion_point(field_mutable:dht.PeerDescriptor.signature) return _s; } -inline const std::string& PeerDescriptor::_internal_signature() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& PeerDescriptor::_internal_signature() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.signature_.Get(); } -inline void PeerDescriptor::_internal_set_signature(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline void PeerDescriptor::_internal_set_signature(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signature_.Set(value, GetArena()); } -inline std::string* PeerDescriptor::_internal_mutable_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::std::string* PROTOBUF_NONNULL PeerDescriptor::_internal_mutable_signature() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.signature_.Mutable( GetArena()); } -inline std::string* PeerDescriptor::release_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE PeerDescriptor::release_signature() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.PeerDescriptor.signature) - if ((_impl_._has_bits_[0] & 0x00000002u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); auto* released = _impl_.signature_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.signature_.Set("", GetArena()); + } return released; } -inline void PeerDescriptor::set_allocated_signature(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void PeerDescriptor::set_allocated_signature(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.signature_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.PeerDescriptor.signature) } @@ -9372,8 +9777,10 @@ inline void PeerDescriptor::set_allocated_signature(std::string* value) { // uint32 port = 1; inline void ConnectivityMethod::clear_port() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::uint32_t ConnectivityMethod::port() const { // @@protoc_insertion_point(field_get:dht.ConnectivityMethod.port) @@ -9381,75 +9788,89 @@ inline ::uint32_t ConnectivityMethod::port() const { } inline void ConnectivityMethod::set_port(::uint32_t value) { _internal_set_port(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.ConnectivityMethod.port) } inline ::uint32_t ConnectivityMethod::_internal_port() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.port_; } inline void ConnectivityMethod::_internal_set_port(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = value; } // string host = 2; inline void ConnectivityMethod::clear_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityMethod::host() const +inline const ::std::string& ConnectivityMethod::host() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityMethod.host) return _internal_host(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityMethod::set_host(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityMethod::set_host(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.host_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityMethod.host) } -inline std::string* ConnectivityMethod::mutable_host() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_host(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityMethod::mutable_host() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_host(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityMethod.host) return _s; } -inline const std::string& ConnectivityMethod::_internal_host() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityMethod::_internal_host() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.host_.Get(); } -inline void ConnectivityMethod::_internal_set_host(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityMethod::_internal_set_host(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.Set(value, GetArena()); } -inline std::string* ConnectivityMethod::_internal_mutable_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityMethod::_internal_mutable_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.host_.Mutable( GetArena()); } -inline std::string* ConnectivityMethod::release_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityMethod::release_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityMethod.host) - return _impl_.host_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.host_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.host_.Set("", GetArena()); + } + return released; } -inline void ConnectivityMethod::set_allocated_host(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityMethod::set_allocated_host(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.host_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.host_.IsDefault()) { - _impl_.host_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityMethod.host) } // bool tls = 3; inline void ConnectivityMethod::clear_tls() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline bool ConnectivityMethod::tls() const { // @@protoc_insertion_point(field_get:dht.ConnectivityMethod.tls) @@ -9457,15 +9878,15 @@ inline bool ConnectivityMethod::tls() const { } inline void ConnectivityMethod::set_tls(bool value) { _internal_set_tls(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:dht.ConnectivityMethod.tls) } inline bool ConnectivityMethod::_internal_tls() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tls_; } inline void ConnectivityMethod::_internal_set_tls(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = value; } @@ -9475,70 +9896,83 @@ inline void ConnectivityMethod::_internal_set_tls(bool value) { // string requestId = 1; inline void RouteMessageWrapper::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& RouteMessageWrapper::requestid() const +inline const ::std::string& RouteMessageWrapper::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.requestId) } -inline std::string* RouteMessageWrapper::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.requestId) return _s; } -inline const std::string& RouteMessageWrapper::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageWrapper::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RouteMessageWrapper::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageWrapper::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RouteMessageWrapper::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RouteMessageWrapper::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageWrapper::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RouteMessageWrapper::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RouteMessageWrapper.requestId) } // .dht.PeerDescriptor sourcePeer = 2; inline bool RouteMessageWrapper::has_sourcepeer() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); PROTOBUF_ASSUME(!value || _impl_.sourcepeer_ != nullptr); return value; } inline void RouteMessageWrapper::clear_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ != nullptr) _impl_.sourcepeer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline const ::dht::PeerDescriptor& RouteMessageWrapper::_internal_sourcepeer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcepeer_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -9546,76 +9980,78 @@ inline const ::dht::PeerDescriptor& RouteMessageWrapper::sourcepeer() const ABSL // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.sourcePeer) return _internal_sourcepeer(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_sourcepeer(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_sourcepeer( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } _impl_.sourcepeer_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.RouteMessageWrapper.sourcePeer) } -inline ::dht::PeerDescriptor* RouteMessageWrapper::release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::PeerDescriptor* released = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* RouteMessageWrapper::unsafe_arena_release_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.sourcePeer) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::PeerDescriptor* temp = _impl_.sourcepeer_; _impl_.sourcepeer_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* RouteMessageWrapper::_internal_mutable_sourcepeer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_sourcepeer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeer_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcepeer_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcepeer_; } -inline ::dht::PeerDescriptor* RouteMessageWrapper::mutable_sourcepeer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_sourcepeer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000020U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcepeer(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.sourcePeer) return _msg; } -inline void RouteMessageWrapper::set_allocated_sourcepeer(::dht::PeerDescriptor* value) { +inline void RouteMessageWrapper::set_allocated_sourcepeer(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcepeer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000020U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000020U); } _impl_.sourcepeer_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -9624,70 +10060,83 @@ inline void RouteMessageWrapper::set_allocated_sourcepeer(::dht::PeerDescriptor* // bytes target = 3; inline void RouteMessageWrapper::clear_target() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -inline const std::string& RouteMessageWrapper::target() const +inline const ::std::string& RouteMessageWrapper::target() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.target) return _internal_target(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_target(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageWrapper::set_target(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); _impl_.target_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.target) } -inline std::string* RouteMessageWrapper::mutable_target() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_target(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_target() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + ::std::string* _s = _internal_mutable_target(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.target) return _s; } -inline const std::string& RouteMessageWrapper::_internal_target() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageWrapper::_internal_target() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.target_.Get(); } -inline void RouteMessageWrapper::_internal_set_target(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageWrapper::_internal_set_target(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.Set(value, GetArena()); } -inline std::string* RouteMessageWrapper::_internal_mutable_target() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_target() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.target_.Mutable( GetArena()); } -inline std::string* RouteMessageWrapper::release_target() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageWrapper::release_target() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.target) - return _impl_.target_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + auto* released = _impl_.target_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.target_.Set("", GetArena()); + } + return released; } -inline void RouteMessageWrapper::set_allocated_target(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::set_allocated_target(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + } _impl_.target_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.target_.IsDefault()) { - _impl_.target_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.target_.IsDefault()) { + _impl_.target_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RouteMessageWrapper.target) } // .dht.Message message = 4; inline bool RouteMessageWrapper::has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U); PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); return value; } inline void RouteMessageWrapper::clear_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline const ::dht::Message& RouteMessageWrapper::_internal_message() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::Message* p = _impl_.message_; return p != nullptr ? *p : reinterpret_cast(::dht::_Message_default_instance_); } @@ -9695,76 +10144,78 @@ inline const ::dht::Message& RouteMessageWrapper::message() const ABSL_ATTRIBUTE // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.message) return _internal_message(); } -inline void RouteMessageWrapper::unsafe_arena_set_allocated_message(::dht::Message* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageWrapper::unsafe_arena_set_allocated_message( + ::dht::Message* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.message_); } _impl_.message_ = reinterpret_cast<::dht::Message*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000040U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.RouteMessageWrapper.message) } -inline ::dht::Message* RouteMessageWrapper::release_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::Message* PROTOBUF_NULLABLE RouteMessageWrapper::release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); ::dht::Message* released = _impl_.message_; _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::Message* RouteMessageWrapper::unsafe_arena_release_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::Message* PROTOBUF_NULLABLE RouteMessageWrapper::unsafe_arena_release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageWrapper.message) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); ::dht::Message* temp = _impl_.message_; _impl_.message_ = nullptr; return temp; } -inline ::dht::Message* RouteMessageWrapper::_internal_mutable_message() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::dht::Message* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::Message>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::Message>(GetArena()); _impl_.message_ = reinterpret_cast<::dht::Message*>(p); } return _impl_.message_; } -inline ::dht::Message* RouteMessageWrapper::mutable_message() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::Message* PROTOBUF_NONNULL RouteMessageWrapper::mutable_message() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000040U); ::dht::Message* _msg = _internal_mutable_message(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.message) return _msg; } -inline void RouteMessageWrapper::set_allocated_message(::dht::Message* value) { +inline void RouteMessageWrapper::set_allocated_message(::dht::Message* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::Message*>(_impl_.message_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.message_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::Message*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000040U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000040U); } _impl_.message_ = reinterpret_cast<::dht::Message*>(value); @@ -9779,18 +10230,21 @@ inline int RouteMessageWrapper::reachablethrough_size() const { return _internal_reachablethrough_size(); } inline void RouteMessageWrapper::clear_reachablethrough() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.reachablethrough_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::mutable_reachablethrough(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_reachablethrough(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.reachableThrough) return _internal_mutable_reachablethrough()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RouteMessageWrapper::mutable_reachablethrough() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::mutable_reachablethrough() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.RouteMessageWrapper.reachableThrough) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_reachablethrough(); } inline const ::dht::PeerDescriptor& RouteMessageWrapper::reachablethrough(int index) const @@ -9798,9 +10252,13 @@ inline const ::dht::PeerDescriptor& RouteMessageWrapper::reachablethrough(int in // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.reachableThrough) return _internal_reachablethrough().Get(index); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::add_reachablethrough() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_reachablethrough()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::add_reachablethrough() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_reachablethrough()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.reachableThrough) return _add; } @@ -9811,12 +10269,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteM } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteMessageWrapper::_internal_reachablethrough() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.reachablethrough_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_reachablethrough() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.reachablethrough_; } @@ -9828,18 +10286,21 @@ inline int RouteMessageWrapper::routingpath_size() const { return _internal_routingpath_size(); } inline void RouteMessageWrapper::clear_routingpath() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.routingpath_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::mutable_routingpath(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::mutable_routingpath(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.routingPath) return _internal_mutable_routingpath()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* RouteMessageWrapper::mutable_routingpath() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::mutable_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:dht.RouteMessageWrapper.routingPath) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_routingpath(); } inline const ::dht::PeerDescriptor& RouteMessageWrapper::routingpath(int index) const @@ -9847,9 +10308,13 @@ inline const ::dht::PeerDescriptor& RouteMessageWrapper::routingpath(int index) // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.routingPath) return _internal_routingpath().Get(index); } -inline ::dht::PeerDescriptor* RouteMessageWrapper::add_routingpath() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_routingpath()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL RouteMessageWrapper::add_routingpath() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_routingpath()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.routingPath) return _add; } @@ -9860,12 +10325,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteM } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& RouteMessageWrapper::_internal_routingpath() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.routingpath_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_routingpath() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.routingpath_; } @@ -9877,96 +10342,67 @@ inline int RouteMessageWrapper::parallelrootnodeids_size() const { return _internal_parallelrootnodeids_size(); } inline void RouteMessageWrapper::clear_parallelrootnodeids() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.parallelrootnodeids_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000004U); } -inline std::string* RouteMessageWrapper::add_parallelrootnodeids() +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::add_parallelrootnodeids() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - std::string* _s = _internal_mutable_parallelrootnodeids()->Add(); + ::google::protobuf::internal::TSanWrite(&_impl_); + ::std::string* _s = + _internal_mutable_parallelrootnodeids()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_add_mutable:dht.RouteMessageWrapper.parallelRootNodeIds) return _s; } -inline const std::string& RouteMessageWrapper::parallelrootnodeids(int index) const +inline const ::std::string& RouteMessageWrapper::parallelrootnodeids(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageWrapper.parallelRootNodeIds) return _internal_parallelrootnodeids().Get(index); } -inline std::string* RouteMessageWrapper::mutable_parallelrootnodeids(int index) +inline ::std::string* PROTOBUF_NONNULL RouteMessageWrapper::mutable_parallelrootnodeids(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.RouteMessageWrapper.parallelRootNodeIds) return _internal_mutable_parallelrootnodeids()->Mutable(index); } -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, const std::string& value) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, std::string&& value) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(std::move(value)); +template +inline void RouteMessageWrapper::set_parallelrootnodeids(int index, Arg_&& value, Args_... args) { + ::google::protobuf::internal::AssignToString(*_internal_mutable_parallelrootnodeids()->Mutable(index), ::std::forward(value), + args... ); // @@protoc_insertion_point(field_set:dht.RouteMessageWrapper.parallelRootNodeIds) } -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, const char* value) { - ABSL_DCHECK(value != nullptr); - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, const char* value, - std::size_t size) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::set_parallelrootnodeids(int index, absl::string_view value) { - _internal_mutable_parallelrootnodeids()->Mutable(index)->assign(value.data(), - value.size()); - // @@protoc_insertion_point(field_set_string_piece:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign(value); - // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(std::string&& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add(std::move(value)); +template +inline void RouteMessageWrapper::add_parallelrootnodeids(Arg_&& value, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::google::protobuf::internal::AddToRepeatedPtrField( + ::google::protobuf::MessageLite::internal_visibility(), GetArena(), + *_internal_mutable_parallelrootnodeids(), ::std::forward(value), + args... ); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_add:dht.RouteMessageWrapper.parallelRootNodeIds) } -inline void RouteMessageWrapper::add_parallelrootnodeids(const char* value) { - ABSL_DCHECK(value != nullptr); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign(value); - // @@protoc_insertion_point(field_add_char:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(const char* value, std::size_t size) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline void RouteMessageWrapper::add_parallelrootnodeids(absl::string_view value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_parallelrootnodeids()->Add()->assign(value.data(), value.size()); - // @@protoc_insertion_point(field_add_string_piece:dht.RouteMessageWrapper.parallelRootNodeIds) -} -inline const ::google::protobuf::RepeatedPtrField& -RouteMessageWrapper::parallelrootnodeids() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::RepeatedPtrField<::std::string>& RouteMessageWrapper::parallelrootnodeids() + const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:dht.RouteMessageWrapper.parallelRootNodeIds) return _internal_parallelrootnodeids(); } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL RouteMessageWrapper::mutable_parallelrootnodeids() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_mutable_list:dht.RouteMessageWrapper.parallelRootNodeIds) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_parallelrootnodeids(); } -inline const ::google::protobuf::RepeatedPtrField& +inline const ::google::protobuf::RepeatedPtrField<::std::string>& RouteMessageWrapper::_internal_parallelrootnodeids() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.parallelrootnodeids_; } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL RouteMessageWrapper::_internal_mutable_parallelrootnodeids() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.parallelrootnodeids_; } @@ -9976,66 +10412,79 @@ RouteMessageWrapper::_internal_mutable_parallelrootnodeids() { // string requestId = 1; inline void RouteMessageAck::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RouteMessageAck::requestid() const +inline const ::std::string& RouteMessageAck::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RouteMessageAck.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RouteMessageAck::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RouteMessageAck.requestId) } -inline std::string* RouteMessageAck::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:dht.RouteMessageAck.requestId) return _s; } -inline const std::string& RouteMessageAck::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RouteMessageAck::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RouteMessageAck::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RouteMessageAck::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RouteMessageAck::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RouteMessageAck::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RouteMessageAck::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RouteMessageAck::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RouteMessageAck.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RouteMessageAck::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RouteMessageAck::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RouteMessageAck.requestId) } // optional .dht.RouteMessageError error = 2; inline bool RouteMessageAck::has_error() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void RouteMessageAck::clear_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::dht::RouteMessageError RouteMessageAck::error() const { // @@protoc_insertion_point(field_get:dht.RouteMessageAck.error) @@ -10043,15 +10492,15 @@ inline ::dht::RouteMessageError RouteMessageAck::error() const { } inline void RouteMessageAck::set_error(::dht::RouteMessageError value) { _internal_set_error(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.RouteMessageAck.error) } inline ::dht::RouteMessageError RouteMessageAck::_internal_error() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::RouteMessageError>(_impl_.error_); } inline void RouteMessageAck::_internal_set_error(::dht::RouteMessageError value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = value; } @@ -10061,8 +10510,10 @@ inline void RouteMessageAck::_internal_set_error(::dht::RouteMessageError value) // uint32 port = 1; inline void ConnectivityRequest::clear_port() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::uint32_t ConnectivityRequest::port() const { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.port) @@ -10070,22 +10521,24 @@ inline ::uint32_t ConnectivityRequest::port() const { } inline void ConnectivityRequest::set_port(::uint32_t value) { _internal_set_port(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.port) } inline ::uint32_t ConnectivityRequest::_internal_port() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.port_; } inline void ConnectivityRequest::_internal_set_port(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.port_ = value; } // bool tls = 2; inline void ConnectivityRequest::clear_tls() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline bool ConnectivityRequest::tls() const { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.tls) @@ -10093,93 +10546,93 @@ inline bool ConnectivityRequest::tls() const { } inline void ConnectivityRequest::set_tls(bool value) { _internal_set_tls(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.tls) } inline bool ConnectivityRequest::_internal_tls() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tls_; } inline void ConnectivityRequest::_internal_set_tls(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tls_ = value; } // optional string host = 3; inline bool ConnectivityRequest::has_host() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); return value; } inline void ConnectivityRequest::clear_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityRequest::host() const +inline const ::std::string& ConnectivityRequest::host() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.host) return _internal_host(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityRequest::set_host(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void ConnectivityRequest::set_host(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.host_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.host) } -inline std::string* ConnectivityRequest::mutable_host() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_host(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityRequest::mutable_host() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_host(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityRequest.host) return _s; } -inline const std::string& ConnectivityRequest::_internal_host() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityRequest::_internal_host() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.host_.Get(); } -inline void ConnectivityRequest::_internal_set_host(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void ConnectivityRequest::_internal_set_host(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.Set(value, GetArena()); } -inline std::string* ConnectivityRequest::_internal_mutable_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL ConnectivityRequest::_internal_mutable_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.host_.Mutable( GetArena()); } -inline std::string* ConnectivityRequest::release_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityRequest::release_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityRequest.host) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); auto* released = _impl_.host_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.host_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.host_.Set("", GetArena()); + } return released; } -inline void ConnectivityRequest::set_allocated_host(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityRequest::set_allocated_host(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.host_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.host_.IsDefault()) { - _impl_.host_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityRequest.host) } // bool allowSelfSignedCertificate = 4; inline void ConnectivityRequest::clear_allowselfsignedcertificate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.allowselfsignedcertificate_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline bool ConnectivityRequest::allowselfsignedcertificate() const { // @@protoc_insertion_point(field_get:dht.ConnectivityRequest.allowSelfSignedCertificate) @@ -10187,15 +10640,15 @@ inline bool ConnectivityRequest::allowselfsignedcertificate() const { } inline void ConnectivityRequest::set_allowselfsignedcertificate(bool value) { _internal_set_allowselfsignedcertificate(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:dht.ConnectivityRequest.allowSelfSignedCertificate) } inline bool ConnectivityRequest::_internal_allowselfsignedcertificate() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.allowselfsignedcertificate_; } inline void ConnectivityRequest::_internal_set_allowselfsignedcertificate(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.allowselfsignedcertificate_ = value; } @@ -10205,123 +10658,148 @@ inline void ConnectivityRequest::_internal_set_allowselfsignedcertificate(bool v // string host = 1; inline void ConnectivityResponse::clear_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ConnectivityResponse::host() const +inline const ::std::string& ConnectivityResponse::host() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.host) return _internal_host(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_host(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_host(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.host_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.host) } -inline std::string* ConnectivityResponse::mutable_host() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_host(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::mutable_host() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_host(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.host) return _s; } -inline const std::string& ConnectivityResponse::_internal_host() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityResponse::_internal_host() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.host_.Get(); } -inline void ConnectivityResponse::_internal_set_host(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityResponse::_internal_set_host(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.host_.Set(value, GetArena()); } -inline std::string* ConnectivityResponse::_internal_mutable_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.host_.Mutable( GetArena()); } -inline std::string* ConnectivityResponse::release_host() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityResponse::release_host() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.host) - return _impl_.host_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.host_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.host_.Set("", GetArena()); + } + return released; } -inline void ConnectivityResponse::set_allocated_host(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::set_allocated_host(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.host_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.host_.IsDefault()) { - _impl_.host_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityResponse.host) } // string natType = 2; inline void ConnectivityResponse::clear_nattype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nattype_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ConnectivityResponse::nattype() const +inline const ::std::string& ConnectivityResponse::nattype() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.natType) return _internal_nattype(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_nattype(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_nattype(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.nattype_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.natType) } -inline std::string* ConnectivityResponse::mutable_nattype() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_nattype(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::mutable_nattype() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_nattype(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.natType) return _s; } -inline const std::string& ConnectivityResponse::_internal_nattype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityResponse::_internal_nattype() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nattype_.Get(); } -inline void ConnectivityResponse::_internal_set_nattype(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityResponse::_internal_set_nattype(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nattype_.Set(value, GetArena()); } -inline std::string* ConnectivityResponse::_internal_mutable_nattype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_nattype() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.nattype_.Mutable( GetArena()); } -inline std::string* ConnectivityResponse::release_nattype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityResponse::release_nattype() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.natType) - return _impl_.nattype_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.nattype_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.nattype_.Set("", GetArena()); + } + return released; } -inline void ConnectivityResponse::set_allocated_nattype(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::set_allocated_nattype(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.nattype_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.nattype_.IsDefault()) { - _impl_.nattype_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.nattype_.IsDefault()) { + _impl_.nattype_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityResponse.natType) } // .dht.ConnectivityMethod websocket = 3; inline bool ConnectivityResponse::has_websocket() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.websocket_ != nullptr); return value; } inline void ConnectivityResponse::clear_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ != nullptr) _impl_.websocket_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::dht::ConnectivityMethod& ConnectivityResponse::_internal_websocket() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::ConnectivityMethod* p = _impl_.websocket_; return p != nullptr ? *p : reinterpret_cast(::dht::_ConnectivityMethod_default_instance_); } @@ -10329,76 +10807,78 @@ inline const ::dht::ConnectivityMethod& ConnectivityResponse::websocket() const // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.websocket) return _internal_websocket(); } -inline void ConnectivityResponse::unsafe_arena_set_allocated_websocket(::dht::ConnectivityMethod* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::unsafe_arena_set_allocated_websocket( + ::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.ConnectivityResponse.websocket) } -inline ::dht::ConnectivityMethod* ConnectivityResponse::release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE ConnectivityResponse::release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* released = _impl_.websocket_; _impl_.websocket_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::ConnectivityMethod* ConnectivityResponse::unsafe_arena_release_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::ConnectivityMethod* PROTOBUF_NULLABLE ConnectivityResponse::unsafe_arena_release_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.websocket) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* temp = _impl_.websocket_; _impl_.websocket_ = nullptr; return temp; } -inline ::dht::ConnectivityMethod* ConnectivityResponse::_internal_mutable_websocket() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_websocket() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.websocket_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::ConnectivityMethod>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityMethod>(GetArena()); _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(p); } return _impl_.websocket_; } -inline ::dht::ConnectivityMethod* ConnectivityResponse::mutable_websocket() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityMethod* PROTOBUF_NONNULL ConnectivityResponse::mutable_websocket() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::ConnectivityMethod* _msg = _internal_mutable_websocket(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.websocket) return _msg; } -inline void ConnectivityResponse::set_allocated_websocket(::dht::ConnectivityMethod* value) { +inline void ConnectivityResponse::set_allocated_websocket(::dht::ConnectivityMethod* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::ConnectivityMethod*>(_impl_.websocket_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.websocket_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::ConnectivityMethod*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.websocket_ = reinterpret_cast<::dht::ConnectivityMethod*>(value); @@ -10407,8 +10887,10 @@ inline void ConnectivityResponse::set_allocated_websocket(::dht::ConnectivityMet // uint32 ipAddress = 4; inline void ConnectivityResponse::clear_ipaddress() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = 0u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000040U); } inline ::uint32_t ConnectivityResponse::ipaddress() const { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.ipAddress) @@ -10416,80 +10898,93 @@ inline ::uint32_t ConnectivityResponse::ipaddress() const { } inline void ConnectivityResponse::set_ipaddress(::uint32_t value) { _internal_set_ipaddress(value); + SetHasBit(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.ipAddress) } inline ::uint32_t ConnectivityResponse::_internal_ipaddress() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ipaddress_; } inline void ConnectivityResponse::_internal_set_ipaddress(::uint32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipaddress_ = value; } // string version = 5; inline void ConnectivityResponse::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& ConnectivityResponse::version() const +inline const ::std::string& ConnectivityResponse::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ConnectivityResponse::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.version) } -inline std::string* ConnectivityResponse::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:dht.ConnectivityResponse.version) return _s; } -inline const std::string& ConnectivityResponse::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ConnectivityResponse::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void ConnectivityResponse::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ConnectivityResponse::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* ConnectivityResponse::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ConnectivityResponse::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* ConnectivityResponse::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ConnectivityResponse::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ConnectivityResponse.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void ConnectivityResponse::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ConnectivityResponse::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ConnectivityResponse.version) } // optional double latitude = 6; inline bool ConnectivityResponse::has_latitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); return value; } inline void ConnectivityResponse::clear_latitude() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline double ConnectivityResponse::latitude() const { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.latitude) @@ -10497,27 +10992,28 @@ inline double ConnectivityResponse::latitude() const { } inline void ConnectivityResponse::set_latitude(double value) { _internal_set_latitude(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.latitude) } inline double ConnectivityResponse::_internal_latitude() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.latitude_; } inline void ConnectivityResponse::_internal_set_latitude(double value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latitude_ = value; } // optional double longitude = 7; inline bool ConnectivityResponse::has_longitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); return value; } inline void ConnectivityResponse::clear_longitude() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.longitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline double ConnectivityResponse::longitude() const { // @@protoc_insertion_point(field_get:dht.ConnectivityResponse.longitude) @@ -10525,15 +11021,15 @@ inline double ConnectivityResponse::longitude() const { } inline void ConnectivityResponse::set_longitude(double value) { _internal_set_longitude(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:dht.ConnectivityResponse.longitude) } inline double ConnectivityResponse::_internal_longitude() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.longitude_; } inline void ConnectivityResponse::_internal_set_longitude(double value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.longitude_ = value; } @@ -10543,17 +11039,18 @@ inline void ConnectivityResponse::_internal_set_longitude(double value) { // .dht.PeerDescriptor sourcePeerDescriptor = 1; inline bool HandshakeRequest::has_sourcepeerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.sourcepeerdescriptor_ != nullptr); return value; } inline void HandshakeRequest::clear_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ != nullptr) _impl_.sourcepeerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::dht::PeerDescriptor& HandshakeRequest::_internal_sourcepeerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcepeerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -10561,76 +11058,78 @@ inline const ::dht::PeerDescriptor& HandshakeRequest::sourcepeerdescriptor() con // @@protoc_insertion_point(field_get:dht.HandshakeRequest.sourcePeerDescriptor) return _internal_sourcepeerdescriptor(); } -inline void HandshakeRequest::unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeRequest::unsafe_arena_set_allocated_sourcepeerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.HandshakeRequest.sourcePeerDescriptor) } -inline ::dht::PeerDescriptor* HandshakeRequest::release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* released = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* HandshakeRequest::unsafe_arena_release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::unsafe_arena_release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeRequest.sourcePeerDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* temp = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* HandshakeRequest::_internal_mutable_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::_internal_mutable_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcepeerdescriptor_; } -inline ::dht::PeerDescriptor* HandshakeRequest::mutable_sourcepeerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::mutable_sourcepeerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcepeerdescriptor(); // @@protoc_insertion_point(field_mutable:dht.HandshakeRequest.sourcePeerDescriptor) return _msg; } -inline void HandshakeRequest::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { +inline void HandshakeRequest::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcepeerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -10639,17 +11138,18 @@ inline void HandshakeRequest::set_allocated_sourcepeerdescriptor(::dht::PeerDesc // optional .dht.PeerDescriptor targetPeerDescriptor = 2; inline bool HandshakeRequest::has_targetpeerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.targetpeerdescriptor_ != nullptr); return value; } inline void HandshakeRequest::clear_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetpeerdescriptor_ != nullptr) _impl_.targetpeerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::dht::PeerDescriptor& HandshakeRequest::_internal_targetpeerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.targetpeerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -10657,76 +11157,78 @@ inline const ::dht::PeerDescriptor& HandshakeRequest::targetpeerdescriptor() con // @@protoc_insertion_point(field_get:dht.HandshakeRequest.targetPeerDescriptor) return _internal_targetpeerdescriptor(); } -inline void HandshakeRequest::unsafe_arena_set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeRequest::unsafe_arena_set_allocated_targetpeerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetpeerdescriptor_); } _impl_.targetpeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.HandshakeRequest.targetPeerDescriptor) } -inline ::dht::PeerDescriptor* HandshakeRequest::release_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::release_targetpeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* released = _impl_.targetpeerdescriptor_; _impl_.targetpeerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* HandshakeRequest::unsafe_arena_release_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeRequest::unsafe_arena_release_targetpeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeRequest.targetPeerDescriptor) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* temp = _impl_.targetpeerdescriptor_; _impl_.targetpeerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* HandshakeRequest::_internal_mutable_targetpeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::_internal_mutable_targetpeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetpeerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.targetpeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.targetpeerdescriptor_; } -inline ::dht::PeerDescriptor* HandshakeRequest::mutable_targetpeerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeRequest::mutable_targetpeerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* _msg = _internal_mutable_targetpeerdescriptor(); // @@protoc_insertion_point(field_mutable:dht.HandshakeRequest.targetPeerDescriptor) return _msg; } -inline void HandshakeRequest::set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* value) { +inline void HandshakeRequest::set_allocated_targetpeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.targetpeerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetpeerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.targetpeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -10735,54 +11237,66 @@ inline void HandshakeRequest::set_allocated_targetpeerdescriptor(::dht::PeerDesc // string version = 3; inline void HandshakeRequest::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HandshakeRequest::version() const +inline const ::std::string& HandshakeRequest::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.HandshakeRequest.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void HandshakeRequest::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HandshakeRequest::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.HandshakeRequest.version) } -inline std::string* HandshakeRequest::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL HandshakeRequest::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:dht.HandshakeRequest.version) return _s; } -inline const std::string& HandshakeRequest::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HandshakeRequest::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void HandshakeRequest::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HandshakeRequest::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* HandshakeRequest::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HandshakeRequest::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* HandshakeRequest::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HandshakeRequest::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeRequest.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void HandshakeRequest::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeRequest::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.HandshakeRequest.version) } @@ -10792,17 +11306,18 @@ inline void HandshakeRequest::set_allocated_version(std::string* value) { // .dht.PeerDescriptor sourcePeerDescriptor = 1; inline bool HandshakeResponse::has_sourcepeerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.sourcepeerdescriptor_ != nullptr); return value; } inline void HandshakeResponse::clear_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ != nullptr) _impl_.sourcepeerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::dht::PeerDescriptor& HandshakeResponse::_internal_sourcepeerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcepeerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -10810,76 +11325,78 @@ inline const ::dht::PeerDescriptor& HandshakeResponse::sourcepeerdescriptor() co // @@protoc_insertion_point(field_get:dht.HandshakeResponse.sourcePeerDescriptor) return _internal_sourcepeerdescriptor(); } -inline void HandshakeResponse::unsafe_arena_set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeResponse::unsafe_arena_set_allocated_sourcepeerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.HandshakeResponse.sourcePeerDescriptor) } -inline ::dht::PeerDescriptor* HandshakeResponse::release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeResponse::release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* released = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* HandshakeResponse::unsafe_arena_release_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE HandshakeResponse::unsafe_arena_release_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeResponse.sourcePeerDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* temp = _impl_.sourcepeerdescriptor_; _impl_.sourcepeerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* HandshakeResponse::_internal_mutable_sourcepeerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeResponse::_internal_mutable_sourcepeerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcepeerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcepeerdescriptor_; } -inline ::dht::PeerDescriptor* HandshakeResponse::mutable_sourcepeerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL HandshakeResponse::mutable_sourcepeerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcepeerdescriptor(); // @@protoc_insertion_point(field_mutable:dht.HandshakeResponse.sourcePeerDescriptor) return _msg; } -inline void HandshakeResponse::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* value) { +inline void HandshakeResponse::set_allocated_sourcepeerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcepeerdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcepeerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.sourcepeerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -10888,13 +11405,14 @@ inline void HandshakeResponse::set_allocated_sourcepeerdescriptor(::dht::PeerDes // optional .dht.HandshakeError error = 2; inline bool HandshakeResponse::has_error() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void HandshakeResponse::clear_error() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline ::dht::HandshakeError HandshakeResponse::error() const { // @@protoc_insertion_point(field_get:dht.HandshakeResponse.error) @@ -10902,68 +11420,80 @@ inline ::dht::HandshakeError HandshakeResponse::error() const { } inline void HandshakeResponse::set_error(::dht::HandshakeError value) { _internal_set_error(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:dht.HandshakeResponse.error) } inline ::dht::HandshakeError HandshakeResponse::_internal_error() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::HandshakeError>(_impl_.error_); } inline void HandshakeResponse::_internal_set_error(::dht::HandshakeError value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.error_ = value; } // string version = 3; inline void HandshakeResponse::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& HandshakeResponse::version() const +inline const ::std::string& HandshakeResponse::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.HandshakeResponse.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void HandshakeResponse::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void HandshakeResponse::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.HandshakeResponse.version) } -inline std::string* HandshakeResponse::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL HandshakeResponse::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:dht.HandshakeResponse.version) return _s; } -inline const std::string& HandshakeResponse::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& HandshakeResponse::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void HandshakeResponse::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void HandshakeResponse::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* HandshakeResponse::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL HandshakeResponse::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* HandshakeResponse::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE HandshakeResponse::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.HandshakeResponse.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void HandshakeResponse::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void HandshakeResponse::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.HandshakeResponse.version) } @@ -10973,70 +11503,83 @@ inline void HandshakeResponse::set_allocated_version(std::string* value) { // string messageId = 1; inline void Message::clear_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.messageid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& Message::messageid() const +inline const ::std::string& Message::messageid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.messageId) return _internal_messageid(); } template -inline PROTOBUF_ALWAYS_INLINE void Message::set_messageid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void Message::set_messageid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.messageid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.Message.messageId) } -inline std::string* Message::mutable_messageid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_messageid(); +inline ::std::string* PROTOBUF_NONNULL Message::mutable_messageid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_messageid(); // @@protoc_insertion_point(field_mutable:dht.Message.messageId) return _s; } -inline const std::string& Message::_internal_messageid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& Message::_internal_messageid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.messageid_.Get(); } -inline void Message::_internal_set_messageid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void Message::_internal_set_messageid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.messageid_.Set(value, GetArena()); } -inline std::string* Message::_internal_mutable_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL Message::_internal_mutable_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.messageid_.Mutable( GetArena()); } -inline std::string* Message::release_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE Message::release_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.messageId) - return _impl_.messageid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.messageid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.messageid_.Set("", GetArena()); + } + return released; } -inline void Message::set_allocated_messageid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::set_allocated_messageid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.messageid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messageid_.IsDefault()) { - _impl_.messageid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.messageid_.IsDefault()) { + _impl_.messageid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.Message.messageId) } // .dht.PeerDescriptor sourceDescriptor = 2; inline bool Message::has_sourcedescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.sourcedescriptor_ != nullptr); return value; } inline void Message::clear_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcedescriptor_ != nullptr) _impl_.sourcedescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::dht::PeerDescriptor& Message::_internal_sourcedescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.sourcedescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -11044,76 +11587,78 @@ inline const ::dht::PeerDescriptor& Message::sourcedescriptor() const ABSL_ATTRI // @@protoc_insertion_point(field_get:dht.Message.sourceDescriptor) return _internal_sourcedescriptor(); } -inline void Message::unsafe_arena_set_allocated_sourcedescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::unsafe_arena_set_allocated_sourcedescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcedescriptor_); } _impl_.sourcedescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.sourceDescriptor) } -inline ::dht::PeerDescriptor* Message::release_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::release_sourcedescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* released = _impl_.sourcedescriptor_; _impl_.sourcedescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* Message::unsafe_arena_release_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::unsafe_arena_release_sourcedescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.sourceDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* temp = _impl_.sourcedescriptor_; _impl_.sourcedescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* Message::_internal_mutable_sourcedescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::_internal_mutable_sourcedescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sourcedescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.sourcedescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.sourcedescriptor_; } -inline ::dht::PeerDescriptor* Message::mutable_sourcedescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::mutable_sourcedescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* _msg = _internal_mutable_sourcedescriptor(); // @@protoc_insertion_point(field_mutable:dht.Message.sourceDescriptor) return _msg; } -inline void Message::set_allocated_sourcedescriptor(::dht::PeerDescriptor* value) { +inline void Message::set_allocated_sourcedescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.sourcedescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sourcedescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.sourcedescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -11122,17 +11667,18 @@ inline void Message::set_allocated_sourcedescriptor(::dht::PeerDescriptor* value // .dht.PeerDescriptor targetDescriptor = 3; inline bool Message::has_targetdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.targetdescriptor_ != nullptr); return value; } inline void Message::clear_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetdescriptor_ != nullptr) _impl_.targetdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::dht::PeerDescriptor& Message::_internal_targetdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.targetdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -11140,76 +11686,78 @@ inline const ::dht::PeerDescriptor& Message::targetdescriptor() const ABSL_ATTRI // @@protoc_insertion_point(field_get:dht.Message.targetDescriptor) return _internal_targetdescriptor(); } -inline void Message::unsafe_arena_set_allocated_targetdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::unsafe_arena_set_allocated_targetdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetdescriptor_); } _impl_.targetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.targetDescriptor) } -inline ::dht::PeerDescriptor* Message::release_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::release_targetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::PeerDescriptor* released = _impl_.targetdescriptor_; _impl_.targetdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* Message::unsafe_arena_release_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE Message::unsafe_arena_release_targetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.targetDescriptor) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::PeerDescriptor* temp = _impl_.targetdescriptor_; _impl_.targetdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* Message::_internal_mutable_targetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::_internal_mutable_targetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.targetdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.targetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.targetdescriptor_; } -inline ::dht::PeerDescriptor* Message::mutable_targetdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL Message::mutable_targetdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::dht::PeerDescriptor* _msg = _internal_mutable_targetdescriptor(); // @@protoc_insertion_point(field_mutable:dht.Message.targetDescriptor) return _msg; } -inline void Message::set_allocated_targetdescriptor(::dht::PeerDescriptor* value) { +inline void Message::set_allocated_targetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::dht::PeerDescriptor*>(_impl_.targetdescriptor_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.targetdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::dht::PeerDescriptor*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.targetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -11218,54 +11766,66 @@ inline void Message::set_allocated_targetdescriptor(::dht::PeerDescriptor* value // string serviceId = 4; inline void Message::clear_serviceid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.serviceid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& Message::serviceid() const +inline const ::std::string& Message::serviceid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.serviceId) return _internal_serviceid(); } template -inline PROTOBUF_ALWAYS_INLINE void Message::set_serviceid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void Message::set_serviceid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.serviceid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.Message.serviceId) } -inline std::string* Message::mutable_serviceid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_serviceid(); +inline ::std::string* PROTOBUF_NONNULL Message::mutable_serviceid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_serviceid(); // @@protoc_insertion_point(field_mutable:dht.Message.serviceId) return _s; } -inline const std::string& Message::_internal_serviceid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& Message::_internal_serviceid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.serviceid_.Get(); } -inline void Message::_internal_set_serviceid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void Message::_internal_set_serviceid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.serviceid_.Set(value, GetArena()); } -inline std::string* Message::_internal_mutable_serviceid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL Message::_internal_mutable_serviceid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.serviceid_.Mutable( GetArena()); } -inline std::string* Message::release_serviceid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE Message::release_serviceid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.Message.serviceId) - return _impl_.serviceid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.serviceid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.serviceid_.Set("", GetArena()); + } + return released; } -inline void Message::set_allocated_serviceid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Message::set_allocated_serviceid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.serviceid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.serviceid_.IsDefault()) { - _impl_.serviceid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.serviceid_.IsDefault()) { + _impl_.serviceid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.Message.serviceId) } @@ -11279,11 +11839,11 @@ inline bool Message::_internal_has_rpcmessage() const { inline void Message::set_has_rpcmessage() { _impl_._oneof_case_[0] = kRpcMessage; } -inline ::protorpc::RpcMessage* Message::release_rpcmessage() { +inline ::protorpc::RpcMessage* PROTOBUF_NULLABLE Message::release_rpcmessage() { // @@protoc_insertion_point(field_release:dht.Message.rpcMessage) if (body_case() == kRpcMessage) { clear_has_body(); - auto* temp = _impl_.body_.rpcmessage_; + auto* temp = reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11294,43 +11854,47 @@ inline ::protorpc::RpcMessage* Message::release_rpcmessage() { } } inline const ::protorpc::RpcMessage& Message::_internal_rpcmessage() const { - return body_case() == kRpcMessage ? *_impl_.body_.rpcmessage_ : reinterpret_cast<::protorpc::RpcMessage&>(::protorpc::_RpcMessage_default_instance_); + return body_case() == kRpcMessage ? static_cast(*reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_)) + : reinterpret_cast(::protorpc::_RpcMessage_default_instance_); } inline const ::protorpc::RpcMessage& Message::rpcmessage() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.rpcMessage) return _internal_rpcmessage(); } -inline ::protorpc::RpcMessage* Message::unsafe_arena_release_rpcmessage() { +inline ::protorpc::RpcMessage* PROTOBUF_NULLABLE Message::unsafe_arena_release_rpcmessage() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.rpcMessage) if (body_case() == kRpcMessage) { clear_has_body(); - auto* temp = _impl_.body_.rpcmessage_; + auto* temp = reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_); _impl_.body_.rpcmessage_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_rpcmessage(::protorpc::RpcMessage* value) { +inline void Message::unsafe_arena_set_allocated_rpcmessage( + ::protorpc::RpcMessage* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_rpcmessage(); - _impl_.body_.rpcmessage_ = value; + _impl_.body_.rpcmessage_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.rpcMessage) } -inline ::protorpc::RpcMessage* Message::_internal_mutable_rpcmessage() { +inline ::protorpc::RpcMessage* PROTOBUF_NONNULL Message::_internal_mutable_rpcmessage() { if (body_case() != kRpcMessage) { clear_body(); set_has_rpcmessage(); - _impl_.body_.rpcmessage_ = CreateMaybeMessage<::protorpc::RpcMessage>(GetArena()); + _impl_.body_.rpcmessage_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::protorpc::RpcMessage>(GetArena())); } - return _impl_.body_.rpcmessage_; + return reinterpret_cast<::protorpc::RpcMessage*>(_impl_.body_.rpcmessage_); } -inline ::protorpc::RpcMessage* Message::mutable_rpcmessage() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::protorpc::RpcMessage* PROTOBUF_NONNULL Message::mutable_rpcmessage() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::protorpc::RpcMessage* _msg = _internal_mutable_rpcmessage(); // @@protoc_insertion_point(field_mutable:dht.Message.rpcMessage) return _msg; @@ -11347,19 +11911,21 @@ inline void Message::set_has_connectivityrequest() { _impl_._oneof_case_[0] = kConnectivityRequest; } inline void Message::clear_connectivityrequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kConnectivityRequest) { if (GetArena() == nullptr) { delete _impl_.body_.connectivityrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityrequest_); } clear_has_body(); } } -inline ::dht::ConnectivityRequest* Message::release_connectivityrequest() { +inline ::dht::ConnectivityRequest* PROTOBUF_NULLABLE Message::release_connectivityrequest() { // @@protoc_insertion_point(field_release:dht.Message.connectivityRequest) if (body_case() == kConnectivityRequest) { clear_has_body(); - auto* temp = _impl_.body_.connectivityrequest_; + auto* temp = reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11370,43 +11936,47 @@ inline ::dht::ConnectivityRequest* Message::release_connectivityrequest() { } } inline const ::dht::ConnectivityRequest& Message::_internal_connectivityrequest() const { - return body_case() == kConnectivityRequest ? *_impl_.body_.connectivityrequest_ : reinterpret_cast<::dht::ConnectivityRequest&>(::dht::_ConnectivityRequest_default_instance_); + return body_case() == kConnectivityRequest ? static_cast(*reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_)) + : reinterpret_cast(::dht::_ConnectivityRequest_default_instance_); } inline const ::dht::ConnectivityRequest& Message::connectivityrequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.connectivityRequest) return _internal_connectivityrequest(); } -inline ::dht::ConnectivityRequest* Message::unsafe_arena_release_connectivityrequest() { +inline ::dht::ConnectivityRequest* PROTOBUF_NULLABLE Message::unsafe_arena_release_connectivityrequest() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.connectivityRequest) if (body_case() == kConnectivityRequest) { clear_has_body(); - auto* temp = _impl_.body_.connectivityrequest_; + auto* temp = reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_); _impl_.body_.connectivityrequest_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_connectivityrequest(::dht::ConnectivityRequest* value) { +inline void Message::unsafe_arena_set_allocated_connectivityrequest( + ::dht::ConnectivityRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_connectivityrequest(); - _impl_.body_.connectivityrequest_ = value; + _impl_.body_.connectivityrequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.connectivityRequest) } -inline ::dht::ConnectivityRequest* Message::_internal_mutable_connectivityrequest() { +inline ::dht::ConnectivityRequest* PROTOBUF_NONNULL Message::_internal_mutable_connectivityrequest() { if (body_case() != kConnectivityRequest) { clear_body(); set_has_connectivityrequest(); - _impl_.body_.connectivityrequest_ = CreateMaybeMessage<::dht::ConnectivityRequest>(GetArena()); + _impl_.body_.connectivityrequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityRequest>(GetArena())); } - return _impl_.body_.connectivityrequest_; + return reinterpret_cast<::dht::ConnectivityRequest*>(_impl_.body_.connectivityrequest_); } -inline ::dht::ConnectivityRequest* Message::mutable_connectivityrequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityRequest* PROTOBUF_NONNULL Message::mutable_connectivityrequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::ConnectivityRequest* _msg = _internal_mutable_connectivityrequest(); // @@protoc_insertion_point(field_mutable:dht.Message.connectivityRequest) return _msg; @@ -11423,19 +11993,21 @@ inline void Message::set_has_connectivityresponse() { _impl_._oneof_case_[0] = kConnectivityResponse; } inline void Message::clear_connectivityresponse() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kConnectivityResponse) { if (GetArena() == nullptr) { delete _impl_.body_.connectivityresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.connectivityresponse_); } clear_has_body(); } } -inline ::dht::ConnectivityResponse* Message::release_connectivityresponse() { +inline ::dht::ConnectivityResponse* PROTOBUF_NULLABLE Message::release_connectivityresponse() { // @@protoc_insertion_point(field_release:dht.Message.connectivityResponse) if (body_case() == kConnectivityResponse) { clear_has_body(); - auto* temp = _impl_.body_.connectivityresponse_; + auto* temp = reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11446,43 +12018,47 @@ inline ::dht::ConnectivityResponse* Message::release_connectivityresponse() { } } inline const ::dht::ConnectivityResponse& Message::_internal_connectivityresponse() const { - return body_case() == kConnectivityResponse ? *_impl_.body_.connectivityresponse_ : reinterpret_cast<::dht::ConnectivityResponse&>(::dht::_ConnectivityResponse_default_instance_); + return body_case() == kConnectivityResponse ? static_cast(*reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_)) + : reinterpret_cast(::dht::_ConnectivityResponse_default_instance_); } inline const ::dht::ConnectivityResponse& Message::connectivityresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.connectivityResponse) return _internal_connectivityresponse(); } -inline ::dht::ConnectivityResponse* Message::unsafe_arena_release_connectivityresponse() { +inline ::dht::ConnectivityResponse* PROTOBUF_NULLABLE Message::unsafe_arena_release_connectivityresponse() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.connectivityResponse) if (body_case() == kConnectivityResponse) { clear_has_body(); - auto* temp = _impl_.body_.connectivityresponse_; + auto* temp = reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_); _impl_.body_.connectivityresponse_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_connectivityresponse(::dht::ConnectivityResponse* value) { +inline void Message::unsafe_arena_set_allocated_connectivityresponse( + ::dht::ConnectivityResponse* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_connectivityresponse(); - _impl_.body_.connectivityresponse_ = value; + _impl_.body_.connectivityresponse_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.connectivityResponse) } -inline ::dht::ConnectivityResponse* Message::_internal_mutable_connectivityresponse() { +inline ::dht::ConnectivityResponse* PROTOBUF_NONNULL Message::_internal_mutable_connectivityresponse() { if (body_case() != kConnectivityResponse) { clear_body(); set_has_connectivityresponse(); - _impl_.body_.connectivityresponse_ = CreateMaybeMessage<::dht::ConnectivityResponse>(GetArena()); + _impl_.body_.connectivityresponse_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::ConnectivityResponse>(GetArena())); } - return _impl_.body_.connectivityresponse_; + return reinterpret_cast<::dht::ConnectivityResponse*>(_impl_.body_.connectivityresponse_); } -inline ::dht::ConnectivityResponse* Message::mutable_connectivityresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::ConnectivityResponse* PROTOBUF_NONNULL Message::mutable_connectivityresponse() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::ConnectivityResponse* _msg = _internal_mutable_connectivityresponse(); // @@protoc_insertion_point(field_mutable:dht.Message.connectivityResponse) return _msg; @@ -11499,19 +12075,21 @@ inline void Message::set_has_handshakerequest() { _impl_._oneof_case_[0] = kHandshakeRequest; } inline void Message::clear_handshakerequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kHandshakeRequest) { if (GetArena() == nullptr) { delete _impl_.body_.handshakerequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakerequest_); } clear_has_body(); } } -inline ::dht::HandshakeRequest* Message::release_handshakerequest() { +inline ::dht::HandshakeRequest* PROTOBUF_NULLABLE Message::release_handshakerequest() { // @@protoc_insertion_point(field_release:dht.Message.handshakeRequest) if (body_case() == kHandshakeRequest) { clear_has_body(); - auto* temp = _impl_.body_.handshakerequest_; + auto* temp = reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11522,43 +12100,47 @@ inline ::dht::HandshakeRequest* Message::release_handshakerequest() { } } inline const ::dht::HandshakeRequest& Message::_internal_handshakerequest() const { - return body_case() == kHandshakeRequest ? *_impl_.body_.handshakerequest_ : reinterpret_cast<::dht::HandshakeRequest&>(::dht::_HandshakeRequest_default_instance_); + return body_case() == kHandshakeRequest ? static_cast(*reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_)) + : reinterpret_cast(::dht::_HandshakeRequest_default_instance_); } inline const ::dht::HandshakeRequest& Message::handshakerequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.handshakeRequest) return _internal_handshakerequest(); } -inline ::dht::HandshakeRequest* Message::unsafe_arena_release_handshakerequest() { +inline ::dht::HandshakeRequest* PROTOBUF_NULLABLE Message::unsafe_arena_release_handshakerequest() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.handshakeRequest) if (body_case() == kHandshakeRequest) { clear_has_body(); - auto* temp = _impl_.body_.handshakerequest_; + auto* temp = reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_); _impl_.body_.handshakerequest_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_handshakerequest(::dht::HandshakeRequest* value) { +inline void Message::unsafe_arena_set_allocated_handshakerequest( + ::dht::HandshakeRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_handshakerequest(); - _impl_.body_.handshakerequest_ = value; + _impl_.body_.handshakerequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.handshakeRequest) } -inline ::dht::HandshakeRequest* Message::_internal_mutable_handshakerequest() { +inline ::dht::HandshakeRequest* PROTOBUF_NONNULL Message::_internal_mutable_handshakerequest() { if (body_case() != kHandshakeRequest) { clear_body(); set_has_handshakerequest(); - _impl_.body_.handshakerequest_ = CreateMaybeMessage<::dht::HandshakeRequest>(GetArena()); + _impl_.body_.handshakerequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::HandshakeRequest>(GetArena())); } - return _impl_.body_.handshakerequest_; + return reinterpret_cast<::dht::HandshakeRequest*>(_impl_.body_.handshakerequest_); } -inline ::dht::HandshakeRequest* Message::mutable_handshakerequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::HandshakeRequest* PROTOBUF_NONNULL Message::mutable_handshakerequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::HandshakeRequest* _msg = _internal_mutable_handshakerequest(); // @@protoc_insertion_point(field_mutable:dht.Message.handshakeRequest) return _msg; @@ -11575,19 +12157,21 @@ inline void Message::set_has_handshakeresponse() { _impl_._oneof_case_[0] = kHandshakeResponse; } inline void Message::clear_handshakeresponse() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kHandshakeResponse) { if (GetArena() == nullptr) { delete _impl_.body_.handshakeresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.handshakeresponse_); } clear_has_body(); } } -inline ::dht::HandshakeResponse* Message::release_handshakeresponse() { +inline ::dht::HandshakeResponse* PROTOBUF_NULLABLE Message::release_handshakeresponse() { // @@protoc_insertion_point(field_release:dht.Message.handshakeResponse) if (body_case() == kHandshakeResponse) { clear_has_body(); - auto* temp = _impl_.body_.handshakeresponse_; + auto* temp = reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11598,43 +12182,47 @@ inline ::dht::HandshakeResponse* Message::release_handshakeresponse() { } } inline const ::dht::HandshakeResponse& Message::_internal_handshakeresponse() const { - return body_case() == kHandshakeResponse ? *_impl_.body_.handshakeresponse_ : reinterpret_cast<::dht::HandshakeResponse&>(::dht::_HandshakeResponse_default_instance_); + return body_case() == kHandshakeResponse ? static_cast(*reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_)) + : reinterpret_cast(::dht::_HandshakeResponse_default_instance_); } inline const ::dht::HandshakeResponse& Message::handshakeresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.handshakeResponse) return _internal_handshakeresponse(); } -inline ::dht::HandshakeResponse* Message::unsafe_arena_release_handshakeresponse() { +inline ::dht::HandshakeResponse* PROTOBUF_NULLABLE Message::unsafe_arena_release_handshakeresponse() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.handshakeResponse) if (body_case() == kHandshakeResponse) { clear_has_body(); - auto* temp = _impl_.body_.handshakeresponse_; + auto* temp = reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_); _impl_.body_.handshakeresponse_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_handshakeresponse(::dht::HandshakeResponse* value) { +inline void Message::unsafe_arena_set_allocated_handshakeresponse( + ::dht::HandshakeResponse* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_handshakeresponse(); - _impl_.body_.handshakeresponse_ = value; + _impl_.body_.handshakeresponse_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.handshakeResponse) } -inline ::dht::HandshakeResponse* Message::_internal_mutable_handshakeresponse() { +inline ::dht::HandshakeResponse* PROTOBUF_NONNULL Message::_internal_mutable_handshakeresponse() { if (body_case() != kHandshakeResponse) { clear_body(); set_has_handshakeresponse(); - _impl_.body_.handshakeresponse_ = CreateMaybeMessage<::dht::HandshakeResponse>(GetArena()); + _impl_.body_.handshakeresponse_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::HandshakeResponse>(GetArena())); } - return _impl_.body_.handshakeresponse_; + return reinterpret_cast<::dht::HandshakeResponse*>(_impl_.body_.handshakeresponse_); } -inline ::dht::HandshakeResponse* Message::mutable_handshakeresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::HandshakeResponse* PROTOBUF_NONNULL Message::mutable_handshakeresponse() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::HandshakeResponse* _msg = _internal_mutable_handshakeresponse(); // @@protoc_insertion_point(field_mutable:dht.Message.handshakeResponse) return _msg; @@ -11651,19 +12239,21 @@ inline void Message::set_has_recursiveoperationrequest() { _impl_._oneof_case_[0] = kRecursiveOperationRequest; } inline void Message::clear_recursiveoperationrequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kRecursiveOperationRequest) { if (GetArena() == nullptr) { delete _impl_.body_.recursiveoperationrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.recursiveoperationrequest_); } clear_has_body(); } } -inline ::dht::RecursiveOperationRequest* Message::release_recursiveoperationrequest() { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE Message::release_recursiveoperationrequest() { // @@protoc_insertion_point(field_release:dht.Message.recursiveOperationRequest) if (body_case() == kRecursiveOperationRequest) { clear_has_body(); - auto* temp = _impl_.body_.recursiveoperationrequest_; + auto* temp = reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -11674,43 +12264,47 @@ inline ::dht::RecursiveOperationRequest* Message::release_recursiveoperationrequ } } inline const ::dht::RecursiveOperationRequest& Message::_internal_recursiveoperationrequest() const { - return body_case() == kRecursiveOperationRequest ? *_impl_.body_.recursiveoperationrequest_ : reinterpret_cast<::dht::RecursiveOperationRequest&>(::dht::_RecursiveOperationRequest_default_instance_); + return body_case() == kRecursiveOperationRequest ? static_cast(*reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_)) + : reinterpret_cast(::dht::_RecursiveOperationRequest_default_instance_); } inline const ::dht::RecursiveOperationRequest& Message::recursiveoperationrequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.Message.recursiveOperationRequest) return _internal_recursiveoperationrequest(); } -inline ::dht::RecursiveOperationRequest* Message::unsafe_arena_release_recursiveoperationrequest() { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE Message::unsafe_arena_release_recursiveoperationrequest() { // @@protoc_insertion_point(field_unsafe_arena_release:dht.Message.recursiveOperationRequest) if (body_case() == kRecursiveOperationRequest) { clear_has_body(); - auto* temp = _impl_.body_.recursiveoperationrequest_; + auto* temp = reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_); _impl_.body_.recursiveoperationrequest_ = nullptr; return temp; } else { return nullptr; } } -inline void Message::unsafe_arena_set_allocated_recursiveoperationrequest(::dht::RecursiveOperationRequest* value) { +inline void Message::unsafe_arena_set_allocated_recursiveoperationrequest( + ::dht::RecursiveOperationRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_recursiveoperationrequest(); - _impl_.body_.recursiveoperationrequest_ = value; + _impl_.body_.recursiveoperationrequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dht.Message.recursiveOperationRequest) } -inline ::dht::RecursiveOperationRequest* Message::_internal_mutable_recursiveoperationrequest() { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL Message::_internal_mutable_recursiveoperationrequest() { if (body_case() != kRecursiveOperationRequest) { clear_body(); set_has_recursiveoperationrequest(); - _impl_.body_.recursiveoperationrequest_ = CreateMaybeMessage<::dht::RecursiveOperationRequest>(GetArena()); + _impl_.body_.recursiveoperationrequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::dht::RecursiveOperationRequest>(GetArena())); } - return _impl_.body_.recursiveoperationrequest_; + return reinterpret_cast<::dht::RecursiveOperationRequest*>(_impl_.body_.recursiveoperationrequest_); } -inline ::dht::RecursiveOperationRequest* Message::mutable_recursiveoperationrequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::RecursiveOperationRequest* PROTOBUF_NONNULL Message::mutable_recursiveoperationrequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::dht::RecursiveOperationRequest* _msg = _internal_mutable_recursiveoperationrequest(); // @@protoc_insertion_point(field_mutable:dht.Message.recursiveOperationRequest) return _msg; @@ -11739,107 +12333,131 @@ inline Message::BodyCase Message::body_case() const { // string description = 1; inline void RtcOffer::clear_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RtcOffer::description() const +inline const ::std::string& RtcOffer::description() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcOffer.description) return _internal_description(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcOffer::set_description(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcOffer::set_description(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.description_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcOffer.description) } -inline std::string* RtcOffer::mutable_description() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_description(); +inline ::std::string* PROTOBUF_NONNULL RtcOffer::mutable_description() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:dht.RtcOffer.description) return _s; } -inline const std::string& RtcOffer::_internal_description() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcOffer::_internal_description() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.description_.Get(); } -inline void RtcOffer::_internal_set_description(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcOffer::_internal_set_description(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.Set(value, GetArena()); } -inline std::string* RtcOffer::_internal_mutable_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcOffer::_internal_mutable_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.description_.Mutable( GetArena()); } -inline std::string* RtcOffer::release_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcOffer::release_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcOffer.description) - return _impl_.description_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.description_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.description_.Set("", GetArena()); + } + return released; } -inline void RtcOffer::set_allocated_description(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcOffer::set_allocated_description(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.description_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcOffer.description) } // string connectionId = 2; inline void RtcOffer::clear_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RtcOffer::connectionid() const +inline const ::std::string& RtcOffer::connectionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcOffer.connectionId) return _internal_connectionid(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcOffer::set_connectionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcOffer::set_connectionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.connectionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcOffer.connectionId) } -inline std::string* RtcOffer::mutable_connectionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_connectionid(); +inline ::std::string* PROTOBUF_NONNULL RtcOffer::mutable_connectionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_connectionid(); // @@protoc_insertion_point(field_mutable:dht.RtcOffer.connectionId) return _s; } -inline const std::string& RtcOffer::_internal_connectionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcOffer::_internal_connectionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connectionid_.Get(); } -inline void RtcOffer::_internal_set_connectionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcOffer::_internal_set_connectionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.Set(value, GetArena()); } -inline std::string* RtcOffer::_internal_mutable_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcOffer::_internal_mutable_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.connectionid_.Mutable( GetArena()); } -inline std::string* RtcOffer::release_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcOffer::release_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcOffer.connectionId) - return _impl_.connectionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.connectionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.connectionid_.Set("", GetArena()); + } + return released; } -inline void RtcOffer::set_allocated_connectionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcOffer::set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.connectionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.connectionid_.IsDefault()) { - _impl_.connectionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.connectionid_.IsDefault()) { + _impl_.connectionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcOffer.connectionId) } @@ -11849,107 +12467,131 @@ inline void RtcOffer::set_allocated_connectionid(std::string* value) { // string description = 1; inline void RtcAnswer::clear_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RtcAnswer::description() const +inline const ::std::string& RtcAnswer::description() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcAnswer.description) return _internal_description(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_description(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_description(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.description_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcAnswer.description) } -inline std::string* RtcAnswer::mutable_description() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_description(); +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::mutable_description() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:dht.RtcAnswer.description) return _s; } -inline const std::string& RtcAnswer::_internal_description() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcAnswer::_internal_description() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.description_.Get(); } -inline void RtcAnswer::_internal_set_description(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcAnswer::_internal_set_description(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.description_.Set(value, GetArena()); } -inline std::string* RtcAnswer::_internal_mutable_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::_internal_mutable_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.description_.Mutable( GetArena()); } -inline std::string* RtcAnswer::release_description() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcAnswer::release_description() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcAnswer.description) - return _impl_.description_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.description_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.description_.Set("", GetArena()); + } + return released; } -inline void RtcAnswer::set_allocated_description(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcAnswer::set_allocated_description(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.description_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcAnswer.description) } // string connectionId = 2; inline void RtcAnswer::clear_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RtcAnswer::connectionid() const +inline const ::std::string& RtcAnswer::connectionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.RtcAnswer.connectionId) return _internal_connectionid(); } template -inline PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_connectionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RtcAnswer::set_connectionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.connectionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.RtcAnswer.connectionId) } -inline std::string* RtcAnswer::mutable_connectionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_connectionid(); +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::mutable_connectionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_connectionid(); // @@protoc_insertion_point(field_mutable:dht.RtcAnswer.connectionId) return _s; } -inline const std::string& RtcAnswer::_internal_connectionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RtcAnswer::_internal_connectionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connectionid_.Get(); } -inline void RtcAnswer::_internal_set_connectionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RtcAnswer::_internal_set_connectionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.Set(value, GetArena()); } -inline std::string* RtcAnswer::_internal_mutable_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RtcAnswer::_internal_mutable_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.connectionid_.Mutable( GetArena()); } -inline std::string* RtcAnswer::release_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RtcAnswer::release_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.RtcAnswer.connectionId) - return _impl_.connectionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.connectionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.connectionid_.Set("", GetArena()); + } + return released; } -inline void RtcAnswer::set_allocated_connectionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RtcAnswer::set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.connectionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.connectionid_.IsDefault()) { - _impl_.connectionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.connectionid_.IsDefault()) { + _impl_.connectionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.RtcAnswer.connectionId) } @@ -11959,160 +12601,196 @@ inline void RtcAnswer::set_allocated_connectionid(std::string* value) { // string candidate = 1; inline void IceCandidate::clear_candidate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.candidate_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& IceCandidate::candidate() const +inline const ::std::string& IceCandidate::candidate() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.IceCandidate.candidate) return _internal_candidate(); } template -inline PROTOBUF_ALWAYS_INLINE void IceCandidate::set_candidate(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void IceCandidate::set_candidate(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.candidate_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.IceCandidate.candidate) } -inline std::string* IceCandidate::mutable_candidate() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_candidate(); +inline ::std::string* PROTOBUF_NONNULL IceCandidate::mutable_candidate() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_candidate(); // @@protoc_insertion_point(field_mutable:dht.IceCandidate.candidate) return _s; } -inline const std::string& IceCandidate::_internal_candidate() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& IceCandidate::_internal_candidate() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.candidate_.Get(); } -inline void IceCandidate::_internal_set_candidate(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void IceCandidate::_internal_set_candidate(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.candidate_.Set(value, GetArena()); } -inline std::string* IceCandidate::_internal_mutable_candidate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL IceCandidate::_internal_mutable_candidate() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.candidate_.Mutable( GetArena()); } -inline std::string* IceCandidate::release_candidate() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE IceCandidate::release_candidate() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.IceCandidate.candidate) - return _impl_.candidate_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.candidate_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.candidate_.Set("", GetArena()); + } + return released; } -inline void IceCandidate::set_allocated_candidate(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void IceCandidate::set_allocated_candidate(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.candidate_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.candidate_.IsDefault()) { - _impl_.candidate_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.candidate_.IsDefault()) { + _impl_.candidate_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.IceCandidate.candidate) } // string mid = 2; inline void IceCandidate::clear_mid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& IceCandidate::mid() const +inline const ::std::string& IceCandidate::mid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.IceCandidate.mid) return _internal_mid(); } template -inline PROTOBUF_ALWAYS_INLINE void IceCandidate::set_mid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void IceCandidate::set_mid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.mid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.IceCandidate.mid) } -inline std::string* IceCandidate::mutable_mid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_mid(); +inline ::std::string* PROTOBUF_NONNULL IceCandidate::mutable_mid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_mid(); // @@protoc_insertion_point(field_mutable:dht.IceCandidate.mid) return _s; } -inline const std::string& IceCandidate::_internal_mid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& IceCandidate::_internal_mid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.mid_.Get(); } -inline void IceCandidate::_internal_set_mid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void IceCandidate::_internal_set_mid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mid_.Set(value, GetArena()); } -inline std::string* IceCandidate::_internal_mutable_mid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL IceCandidate::_internal_mutable_mid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.mid_.Mutable( GetArena()); } -inline std::string* IceCandidate::release_mid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE IceCandidate::release_mid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.IceCandidate.mid) - return _impl_.mid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.mid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.mid_.Set("", GetArena()); + } + return released; } -inline void IceCandidate::set_allocated_mid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void IceCandidate::set_allocated_mid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.mid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mid_.IsDefault()) { - _impl_.mid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.mid_.IsDefault()) { + _impl_.mid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.IceCandidate.mid) } // string connectionId = 3; inline void IceCandidate::clear_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& IceCandidate::connectionid() const +inline const ::std::string& IceCandidate::connectionid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.IceCandidate.connectionId) return _internal_connectionid(); } template -inline PROTOBUF_ALWAYS_INLINE void IceCandidate::set_connectionid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void IceCandidate::set_connectionid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.connectionid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.IceCandidate.connectionId) } -inline std::string* IceCandidate::mutable_connectionid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_connectionid(); +inline ::std::string* PROTOBUF_NONNULL IceCandidate::mutable_connectionid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_connectionid(); // @@protoc_insertion_point(field_mutable:dht.IceCandidate.connectionId) return _s; } -inline const std::string& IceCandidate::_internal_connectionid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& IceCandidate::_internal_connectionid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connectionid_.Get(); } -inline void IceCandidate::_internal_set_connectionid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void IceCandidate::_internal_set_connectionid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connectionid_.Set(value, GetArena()); } -inline std::string* IceCandidate::_internal_mutable_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL IceCandidate::_internal_mutable_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.connectionid_.Mutable( GetArena()); } -inline std::string* IceCandidate::release_connectionid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE IceCandidate::release_connectionid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.IceCandidate.connectionId) - return _impl_.connectionid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.connectionid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.connectionid_.Set("", GetArena()); + } + return released; } -inline void IceCandidate::set_allocated_connectionid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void IceCandidate::set_allocated_connectionid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.connectionid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.connectionid_.IsDefault()) { - _impl_.connectionid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.connectionid_.IsDefault()) { + _impl_.connectionid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.IceCandidate.connectionId) } @@ -12122,54 +12800,66 @@ inline void IceCandidate::set_allocated_connectionid(std::string* value) { // string lockId = 1; inline void LockRequest::clear_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& LockRequest::lockid() const +inline const ::std::string& LockRequest::lockid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.LockRequest.lockId) return _internal_lockid(); } template -inline PROTOBUF_ALWAYS_INLINE void LockRequest::set_lockid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void LockRequest::set_lockid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.lockid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.LockRequest.lockId) } -inline std::string* LockRequest::mutable_lockid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_lockid(); +inline ::std::string* PROTOBUF_NONNULL LockRequest::mutable_lockid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_lockid(); // @@protoc_insertion_point(field_mutable:dht.LockRequest.lockId) return _s; } -inline const std::string& LockRequest::_internal_lockid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& LockRequest::_internal_lockid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.lockid_.Get(); } -inline void LockRequest::_internal_set_lockid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void LockRequest::_internal_set_lockid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.Set(value, GetArena()); } -inline std::string* LockRequest::_internal_mutable_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL LockRequest::_internal_mutable_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.lockid_.Mutable( GetArena()); } -inline std::string* LockRequest::release_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE LockRequest::release_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.LockRequest.lockId) - return _impl_.lockid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.lockid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.lockid_.Set("", GetArena()); + } + return released; } -inline void LockRequest::set_allocated_lockid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void LockRequest::set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.lockid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lockid_.IsDefault()) { - _impl_.lockid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lockid_.IsDefault()) { + _impl_.lockid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.LockRequest.lockId) } @@ -12179,54 +12869,66 @@ inline void LockRequest::set_allocated_lockid(std::string* value) { // string lockId = 1; inline void UnlockRequest::clear_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& UnlockRequest::lockid() const +inline const ::std::string& UnlockRequest::lockid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.UnlockRequest.lockId) return _internal_lockid(); } template -inline PROTOBUF_ALWAYS_INLINE void UnlockRequest::set_lockid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void UnlockRequest::set_lockid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.lockid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.UnlockRequest.lockId) } -inline std::string* UnlockRequest::mutable_lockid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_lockid(); +inline ::std::string* PROTOBUF_NONNULL UnlockRequest::mutable_lockid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_lockid(); // @@protoc_insertion_point(field_mutable:dht.UnlockRequest.lockId) return _s; } -inline const std::string& UnlockRequest::_internal_lockid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& UnlockRequest::_internal_lockid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.lockid_.Get(); } -inline void UnlockRequest::_internal_set_lockid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void UnlockRequest::_internal_set_lockid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lockid_.Set(value, GetArena()); } -inline std::string* UnlockRequest::_internal_mutable_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL UnlockRequest::_internal_mutable_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.lockid_.Mutable( GetArena()); } -inline std::string* UnlockRequest::release_lockid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE UnlockRequest::release_lockid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.UnlockRequest.lockId) - return _impl_.lockid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.lockid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.lockid_.Set("", GetArena()); + } + return released; } -inline void UnlockRequest::set_allocated_lockid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void UnlockRequest::set_allocated_lockid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.lockid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lockid_.IsDefault()) { - _impl_.lockid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lockid_.IsDefault()) { + _impl_.lockid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.UnlockRequest.lockId) } @@ -12236,8 +12938,10 @@ inline void UnlockRequest::set_allocated_lockid(std::string* value) { // bool accepted = 1; inline void LockResponse::clear_accepted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline bool LockResponse::accepted() const { // @@protoc_insertion_point(field_get:dht.LockResponse.accepted) @@ -12245,15 +12949,15 @@ inline bool LockResponse::accepted() const { } inline void LockResponse::set_accepted(bool value) { _internal_set_accepted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:dht.LockResponse.accepted) } inline bool LockResponse::_internal_accepted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.accepted_; } inline void LockResponse::_internal_set_accepted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = value; } @@ -12263,8 +12967,10 @@ inline void LockResponse::_internal_set_accepted(bool value) { // .dht.DisconnectMode disconnectMode = 1; inline void DisconnectNotice::clear_disconnectmode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.disconnectmode_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline ::dht::DisconnectMode DisconnectNotice::disconnectmode() const { // @@protoc_insertion_point(field_get:dht.DisconnectNotice.disconnectMode) @@ -12272,15 +12978,15 @@ inline ::dht::DisconnectMode DisconnectNotice::disconnectmode() const { } inline void DisconnectNotice::set_disconnectmode(::dht::DisconnectMode value) { _internal_set_disconnectmode(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:dht.DisconnectNotice.disconnectMode) } inline ::dht::DisconnectMode DisconnectNotice::_internal_disconnectmode() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::dht::DisconnectMode>(_impl_.disconnectmode_); } inline void DisconnectNotice::_internal_set_disconnectmode(::dht::DisconnectMode value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.disconnectmode_ = value; } @@ -12290,54 +12996,66 @@ inline void DisconnectNotice::_internal_set_disconnectmode(::dht::DisconnectMode // bytes key = 1; inline void ExternalFetchDataRequest::clear_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ExternalFetchDataRequest::key() const +inline const ::std::string& ExternalFetchDataRequest::key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:dht.ExternalFetchDataRequest.key) return _internal_key(); } template -inline PROTOBUF_ALWAYS_INLINE void ExternalFetchDataRequest::set_key(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ExternalFetchDataRequest::set_key(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:dht.ExternalFetchDataRequest.key) } -inline std::string* ExternalFetchDataRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_key(); +inline ::std::string* PROTOBUF_NONNULL ExternalFetchDataRequest::mutable_key() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:dht.ExternalFetchDataRequest.key) return _s; } -inline const std::string& ExternalFetchDataRequest::_internal_key() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ExternalFetchDataRequest::_internal_key() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.key_.Get(); } -inline void ExternalFetchDataRequest::_internal_set_key(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ExternalFetchDataRequest::_internal_set_key(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.key_.Set(value, GetArena()); } -inline std::string* ExternalFetchDataRequest::_internal_mutable_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ExternalFetchDataRequest::_internal_mutable_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.key_.Mutable( GetArena()); } -inline std::string* ExternalFetchDataRequest::release_key() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ExternalFetchDataRequest::release_key() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:dht.ExternalFetchDataRequest.key) - return _impl_.key_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.key_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.key_.Set("", GetArena()); + } + return released; } -inline void ExternalFetchDataRequest::set_allocated_key(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ExternalFetchDataRequest::set_allocated_key(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.key_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:dht.ExternalFetchDataRequest.key) } @@ -12353,18 +13071,21 @@ inline int ExternalFetchDataResponse::entries_size() const { return _internal_entries_size(); } inline void ExternalFetchDataResponse::clear_entries() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.entries_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::dht::DataEntry* ExternalFetchDataResponse::mutable_entries(int index) +inline ::dht::DataEntry* PROTOBUF_NONNULL ExternalFetchDataResponse::mutable_entries(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:dht.ExternalFetchDataResponse.entries) return _internal_mutable_entries()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* ExternalFetchDataResponse::mutable_entries() +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL ExternalFetchDataResponse::mutable_entries() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:dht.ExternalFetchDataResponse.entries) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_entries(); } inline const ::dht::DataEntry& ExternalFetchDataResponse::entries(int index) const @@ -12372,9 +13093,13 @@ inline const ::dht::DataEntry& ExternalFetchDataResponse::entries(int index) con // @@protoc_insertion_point(field_get:dht.ExternalFetchDataResponse.entries) return _internal_entries().Get(index); } -inline ::dht::DataEntry* ExternalFetchDataResponse::add_entries() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::DataEntry* _add = _internal_mutable_entries()->Add(); +inline ::dht::DataEntry* PROTOBUF_NONNULL ExternalFetchDataResponse::add_entries() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::DataEntry* _add = + _internal_mutable_entries()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:dht.ExternalFetchDataResponse.entries) return _add; } @@ -12385,12 +13110,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& ExternalFet } inline const ::google::protobuf::RepeatedPtrField<::dht::DataEntry>& ExternalFetchDataResponse::_internal_entries() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.entries_; } -inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* +inline ::google::protobuf::RepeatedPtrField<::dht::DataEntry>* PROTOBUF_NONNULL ExternalFetchDataResponse::_internal_mutable_entries() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.entries_; } @@ -12408,37 +13133,37 @@ namespace protobuf { template <> struct is_proto_enum<::dht::RecursiveOperation> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::RecursiveOperation>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::RecursiveOperation>() { return ::dht::RecursiveOperation_descriptor(); } template <> struct is_proto_enum<::dht::NodeType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::NodeType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::NodeType>() { return ::dht::NodeType_descriptor(); } template <> struct is_proto_enum<::dht::RpcResponseError> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::RpcResponseError>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::RpcResponseError>() { return ::dht::RpcResponseError_descriptor(); } template <> struct is_proto_enum<::dht::RouteMessageError> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::RouteMessageError>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::RouteMessageError>() { return ::dht::RouteMessageError_descriptor(); } template <> struct is_proto_enum<::dht::HandshakeError> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::HandshakeError>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::HandshakeError>() { return ::dht::HandshakeError_descriptor(); } template <> struct is_proto_enum<::dht::DisconnectMode> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::dht::DisconnectMode>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::dht::DisconnectMode>() { return ::dht::DisconnectMode_descriptor(); } @@ -12449,4 +13174,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::dht::DisconnectMode>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh +#endif // packages_2fdht_2fprotos_2fDhtRpc_2eproto_2epb_2eh diff --git a/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.cc b/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.cc index e6eeefa7..3fc29231 100644 --- a/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.cc +++ b/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/network/protos/NetworkRpc.proto +// Protobuf C++ Version: 6.33.4 #include "packages/network/protos/NetworkRpc.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" @@ -18,15 +23,22 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; inline constexpr TemporaryConnectionResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : accepted_{false}, - _cached_size_{0} {} + : _cached_size_{0}, + accepted_{false} {} template PROTOBUF_CONSTEXPR TemporaryConnectionResponse::TemporaryConnectionResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(TemporaryConnectionResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct TemporaryConnectionResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR TemporaryConnectionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TemporaryConnectionResponseDefaultTypeInternal() {} @@ -37,8 +49,14 @@ struct TemporaryConnectionResponseDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemporaryConnectionResponseDefaultTypeInternal _TemporaryConnectionResponse_default_instance_; - template -PROTOBUF_CONSTEXPR TemporaryConnectionRequest::TemporaryConnectionRequest(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR TemporaryConnectionRequest::TemporaryConnectionRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(TemporaryConnectionRequest_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct TemporaryConnectionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR TemporaryConnectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TemporaryConnectionRequestDefaultTypeInternal() {} @@ -69,7 +87,13 @@ inline constexpr StreamPartHandshakeRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR StreamPartHandshakeRequest::StreamPartHandshakeRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(StreamPartHandshakeRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct StreamPartHandshakeRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR StreamPartHandshakeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StreamPartHandshakeRequestDefaultTypeInternal() {} @@ -83,12 +107,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ProxyConnectionResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : accepted_{false}, - _cached_size_{0} {} + : _cached_size_{0}, + accepted_{false} {} template PROTOBUF_CONSTEXPR ProxyConnectionResponse::ProxyConnectionResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ProxyConnectionResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ProxyConnectionResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ProxyConnectionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ProxyConnectionResponseDefaultTypeInternal() {} @@ -102,15 +132,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ProxyConnectionRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : userid_( + : _cached_size_{0}, + userid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - direction_{static_cast< ::ProxyDirection >(0)}, - _cached_size_{0} {} + direction_{static_cast< ::ProxyDirection >(0)} {} template PROTOBUF_CONSTEXPR ProxyConnectionRequest::ProxyConnectionRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ProxyConnectionRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ProxyConnectionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ProxyConnectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ProxyConnectionRequestDefaultTypeInternal() {} @@ -121,8 +157,14 @@ struct ProxyConnectionRequestDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ProxyConnectionRequestDefaultTypeInternal _ProxyConnectionRequest_default_instance_; - template -PROTOBUF_CONSTEXPR NodeInfoRequest::NodeInfoRequest(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR NodeInfoRequest::NodeInfoRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(NodeInfoRequest_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct NodeInfoRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR NodeInfoRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NodeInfoRequestDefaultTypeInternal() {} @@ -136,13 +178,19 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr MessageRef::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : timestamp_{::int64_t{0}}, - sequencenumber_{0}, - _cached_size_{0} {} + : _cached_size_{0}, + timestamp_{::int64_t{0}}, + sequencenumber_{0} {} template PROTOBUF_CONSTEXPR MessageRef::MessageRef(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(MessageRef_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct MessageRefDefaultTypeInternal { PROTOBUF_CONSTEXPR MessageRefDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MessageRefDefaultTypeInternal() {} @@ -156,7 +204,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr MessageID::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : streamid_( + : _cached_size_{0}, + streamid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), publisherid_( @@ -167,12 +216,17 @@ inline constexpr MessageID::Impl_::Impl_( ::_pbi::ConstantInitialized()), timestamp_{::int64_t{0}}, streampartition_{0}, - sequencenumber_{0}, - _cached_size_{0} {} + sequencenumber_{0} {} template PROTOBUF_CONSTEXPR MessageID::MessageID(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(MessageID_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct MessageIDDefaultTypeInternal { PROTOBUF_CONSTEXPR MessageIDDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MessageIDDefaultTypeInternal() {} @@ -186,15 +240,21 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr LeaveStreamPartNotice::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : streampartid_( + : _cached_size_{0}, + streampartid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - isentrypoint_{false}, - _cached_size_{0} {} + isentrypoint_{false} {} template PROTOBUF_CONSTEXPR LeaveStreamPartNotice::LeaveStreamPartNotice(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(LeaveStreamPartNotice_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct LeaveStreamPartNoticeDefaultTypeInternal { PROTOBUF_CONSTEXPR LeaveStreamPartNoticeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LeaveStreamPartNoticeDefaultTypeInternal() {} @@ -208,12 +268,18 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr InterleaveResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : accepted_{false}, - _cached_size_{0} {} + : _cached_size_{0}, + accepted_{false} {} template PROTOBUF_CONSTEXPR InterleaveResponse::InterleaveResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(InterleaveResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct InterleaveResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR InterleaveResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~InterleaveResponseDefaultTypeInternal() {} @@ -227,7 +293,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr GroupKeyRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : groupkeyids_{}, + : _cached_size_{0}, + groupkeyids_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), @@ -236,12 +303,17 @@ inline constexpr GroupKeyRequest::Impl_::Impl_( ::_pbi::ConstantInitialized()), rsapublickey_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR GroupKeyRequest::GroupKeyRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(GroupKeyRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct GroupKeyRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR GroupKeyRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GroupKeyRequestDefaultTypeInternal() {} @@ -255,17 +327,23 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr GroupKey::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : id_( + : _cached_size_{0}, + id_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), data_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR GroupKey::GroupKey(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(GroupKey_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct GroupKeyDefaultTypeInternal { PROTOBUF_CONSTEXPR GroupKeyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GroupKeyDefaultTypeInternal() {} @@ -276,8 +354,14 @@ struct GroupKeyDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupKeyDefaultTypeInternal _GroupKey_default_instance_; - template -PROTOBUF_CONSTEXPR CloseTemporaryConnection::CloseTemporaryConnection(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR CloseTemporaryConnection::CloseTemporaryConnection(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(CloseTemporaryConnection_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct CloseTemporaryConnectionDefaultTypeInternal { PROTOBUF_CONSTEXPR CloseTemporaryConnectionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~CloseTemporaryConnectionDefaultTypeInternal() {} @@ -291,18 +375,24 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr GroupKeyResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : groupkeys_{}, + : _cached_size_{0}, + groupkeys_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), recipientid_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR GroupKeyResponse::GroupKeyResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(GroupKeyResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct GroupKeyResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GroupKeyResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GroupKeyResponseDefaultTypeInternal() {} @@ -329,7 +419,13 @@ inline constexpr ContentMessage::Impl_::Impl_( template PROTOBUF_CONSTEXPR ContentMessage::ContentMessage(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ContentMessage_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ContentMessageDefaultTypeInternal { PROTOBUF_CONSTEXPR ContentMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ContentMessageDefaultTypeInternal() {} @@ -343,16 +439,22 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr StreamPartitionInfo::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : controllayerneighbors_{}, + : _cached_size_{0}, + controllayerneighbors_{}, contentdeliverylayerneighbors_{}, id_( &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _cached_size_{0} {} + ::_pbi::ConstantInitialized()) {} template PROTOBUF_CONSTEXPR StreamPartitionInfo::StreamPartitionInfo(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(StreamPartitionInfo_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct StreamPartitionInfoDefaultTypeInternal { PROTOBUF_CONSTEXPR StreamPartitionInfoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StreamPartitionInfoDefaultTypeInternal() {} @@ -375,7 +477,13 @@ inline constexpr StreamPartHandshakeResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR StreamPartHandshakeResponse::StreamPartHandshakeResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(StreamPartHandshakeResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct StreamPartHandshakeResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR StreamPartHandshakeResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StreamPartHandshakeResponseDefaultTypeInternal() {} @@ -401,7 +509,13 @@ inline constexpr StreamMessage::Impl_::Impl_( template PROTOBUF_CONSTEXPR StreamMessage::StreamMessage(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(StreamMessage_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct StreamMessageDefaultTypeInternal { PROTOBUF_CONSTEXPR StreamMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StreamMessageDefaultTypeInternal() {} @@ -415,16 +529,22 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr NeighborUpdate::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : neighbordescriptors_{}, + : _cached_size_{0}, + neighbordescriptors_{}, streampartid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - removeme_{false}, - _cached_size_{0} {} + removeme_{false} {} template PROTOBUF_CONSTEXPR NeighborUpdate::NeighborUpdate(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(NeighborUpdate_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct NeighborUpdateDefaultTypeInternal { PROTOBUF_CONSTEXPR NeighborUpdateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NeighborUpdateDefaultTypeInternal() {} @@ -443,7 +563,13 @@ inline constexpr InterleaveRequest::Impl_::Impl_( template PROTOBUF_CONSTEXPR InterleaveRequest::InterleaveRequest(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(InterleaveRequest_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct InterleaveRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR InterleaveRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~InterleaveRequestDefaultTypeInternal() {} @@ -457,13 +583,19 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr ControlLayerInfo::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept - : neighbors_{}, - connections_{}, - _cached_size_{0} {} + : _cached_size_{0}, + neighbors_{}, + connections_{} {} template PROTOBUF_CONSTEXPR ControlLayerInfo::ControlLayerInfo(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ControlLayerInfo_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct ControlLayerInfoDefaultTypeInternal { PROTOBUF_CONSTEXPR ControlLayerInfoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ControlLayerInfoDefaultTypeInternal() {} @@ -487,7 +619,13 @@ inline constexpr NodeInfoResponse::Impl_::Impl_( template PROTOBUF_CONSTEXPR NodeInfoResponse::NodeInfoResponse(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(NodeInfoResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct NodeInfoResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR NodeInfoResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NodeInfoResponseDefaultTypeInternal() {} @@ -498,300 +636,217 @@ struct NodeInfoResponseDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodeInfoResponseDefaultTypeInternal _NodeInfoResponse_default_instance_; -static ::_pb::Metadata file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[22]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[4]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[4]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto = nullptr; -const ::uint32_t TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::MessageID, _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(::MessageID, _impl_.streamid_), - PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.streampartition_), - PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.timestamp_), - PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.sequencenumber_), - PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.publisherid_), - PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.messagechainid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::MessageRef, _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(::MessageRef, _impl_.timestamp_), - PROTOBUF_FIELD_OFFSET(::MessageRef, _impl_.sequencenumber_), - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::StreamMessage, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _split_ - ~0u, // no sizeof(Split) - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.messageid_), - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.previousmessageref_), - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.signature_), - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.signaturetype_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.body_), - 0, - 1, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::ContentMessage, _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(::ContentMessage, _impl_.content_), - PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.contenttype_), - PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.encryptiontype_), - PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.groupkeyid_), - PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.newgroupkey_), - ~0u, - ~0u, - ~0u, - 0, - 1, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _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(::GroupKeyRequest, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.recipientid_), - PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.rsapublickey_), - PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.groupkeyids_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _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(::GroupKeyResponse, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _impl_.recipientid_), - PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _impl_.groupkeys_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::GroupKey, _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(::GroupKey, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::GroupKey, _impl_.data_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _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(::StreamPartHandshakeRequest, _impl_.streampartid_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.concurrenthandshakenodeid_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.neighbornodeids_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.interleavenodeid_), - ~0u, - ~0u, - 0, - ~0u, - 1, - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _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(::StreamPartHandshakeResponse, _impl_.accepted_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_.interleavetargetdescriptor_), - ~0u, - ~0u, - 0, - PROTOBUF_FIELD_OFFSET(::InterleaveRequest, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::InterleaveRequest, _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(::InterleaveRequest, _impl_.interleavetargetdescriptor_), - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::InterleaveResponse, _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(::InterleaveResponse, _impl_.accepted_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::LeaveStreamPartNotice, _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(::LeaveStreamPartNotice, _impl_.streampartid_), - PROTOBUF_FIELD_OFFSET(::LeaveStreamPartNotice, _impl_.isentrypoint_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _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(::NeighborUpdate, _impl_.streampartid_), - PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _impl_.removeme_), - PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _impl_.neighbordescriptors_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::ProxyConnectionRequest, _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(::ProxyConnectionRequest, _impl_.direction_), - PROTOBUF_FIELD_OFFSET(::ProxyConnectionRequest, _impl_.userid_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::ProxyConnectionResponse, _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(::ProxyConnectionResponse, _impl_.accepted_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::TemporaryConnectionRequest, _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(::TemporaryConnectionResponse, _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(::TemporaryConnectionResponse, _impl_.accepted_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::CloseTemporaryConnection, _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(::StreamPartitionInfo, _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(::StreamPartitionInfo, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::StreamPartitionInfo, _impl_.controllayerneighbors_), - PROTOBUF_FIELD_OFFSET(::StreamPartitionInfo, _impl_.contentdeliverylayerneighbors_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::ControlLayerInfo, _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(::ControlLayerInfo, _impl_.neighbors_), - PROTOBUF_FIELD_OFFSET(::ControlLayerInfo, _impl_.connections_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::NodeInfoRequest, _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(::NodeInfoResponse, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _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(::NodeInfoResponse, _impl_.peerdescriptor_), - PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.streampartitions_), - PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.controllayer_), - PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.version_), - 0, - ~0u, - 1, - ~0u, +const ::uint32_t + TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_._has_bits_), + 9, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.streamid_), + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.streampartition_), + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.sequencenumber_), + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.publisherid_), + PROTOBUF_FIELD_OFFSET(::MessageID, _impl_.messagechainid_), + 0, + 4, + 3, + 5, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::MessageRef, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::MessageRef, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::MessageRef, _impl_.sequencenumber_), + 0, + 1, + 0x085, // bitmap + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_._oneof_case_[0]), + 12, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.messageid_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.previousmessageref_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.signature_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.signaturetype_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_.body_), + 1, + 2, + 0, + 3, + ~0u, + ~0u, + ~0u, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_._has_bits_), + 8, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.content_), + PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.contenttype_), + PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.encryptiontype_), + PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.groupkeyid_), + PROTOBUF_FIELD_OFFSET(::ContentMessage, _impl_.newgroupkey_), + 0, + 3, + 4, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.recipientid_), + PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.rsapublickey_), + PROTOBUF_FIELD_OFFSET(::GroupKeyRequest, _impl_.groupkeyids_), + 1, + 2, + 3, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _impl_.recipientid_), + PROTOBUF_FIELD_OFFSET(::GroupKeyResponse, _impl_.groupkeys_), + 1, + 2, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::GroupKey, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::GroupKey, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::GroupKey, _impl_.data_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_._has_bits_), + 8, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.streampartid_), + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.concurrenthandshakenodeid_), + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.neighbornodeids_), + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeRequest, _impl_.interleavenodeid_), + 1, + 2, + 3, + 0, + 4, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_.accepted_), + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::StreamPartHandshakeResponse, _impl_.interleavetargetdescriptor_), + 2, + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::InterleaveRequest, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::InterleaveRequest, _impl_.interleavetargetdescriptor_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::InterleaveResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::InterleaveResponse, _impl_.accepted_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::LeaveStreamPartNotice, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::LeaveStreamPartNotice, _impl_.streampartid_), + PROTOBUF_FIELD_OFFSET(::LeaveStreamPartNotice, _impl_.isentrypoint_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _impl_.streampartid_), + PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _impl_.removeme_), + PROTOBUF_FIELD_OFFSET(::NeighborUpdate, _impl_.neighbordescriptors_), + 1, + 2, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ProxyConnectionRequest, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ProxyConnectionRequest, _impl_.direction_), + PROTOBUF_FIELD_OFFSET(::ProxyConnectionRequest, _impl_.userid_), + 1, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ProxyConnectionResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ProxyConnectionResponse, _impl_.accepted_), + 0, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::TemporaryConnectionResponse, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::TemporaryConnectionResponse, _impl_.accepted_), + 0, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::StreamPartitionInfo, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::StreamPartitionInfo, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::StreamPartitionInfo, _impl_.controllayerneighbors_), + PROTOBUF_FIELD_OFFSET(::StreamPartitionInfo, _impl_.contentdeliverylayerneighbors_), + 2, + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::ControlLayerInfo, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::ControlLayerInfo, _impl_.neighbors_), + PROTOBUF_FIELD_OFFSET(::ControlLayerInfo, _impl_.connections_), + 0, + 1, + 0x000, // bitmap + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_._has_bits_), + 7, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.peerdescriptor_), + PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.streampartitions_), + PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.controllayer_), + PROTOBUF_FIELD_OFFSET(::NodeInfoResponse, _impl_.version_), + 2, + 0, + 3, + 1, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, -1, -1, sizeof(::MessageID)}, - {14, -1, -1, sizeof(::MessageRef)}, - {24, 40, -1, sizeof(::StreamMessage)}, - {47, 60, -1, sizeof(::ContentMessage)}, - {65, -1, -1, sizeof(::GroupKeyRequest)}, - {77, -1, -1, sizeof(::GroupKeyResponse)}, - {88, -1, -1, sizeof(::GroupKey)}, - {98, 111, -1, sizeof(::StreamPartHandshakeRequest)}, - {116, 127, -1, sizeof(::StreamPartHandshakeResponse)}, - {130, 139, -1, sizeof(::InterleaveRequest)}, - {140, -1, -1, sizeof(::InterleaveResponse)}, - {149, -1, -1, sizeof(::LeaveStreamPartNotice)}, - {159, -1, -1, sizeof(::NeighborUpdate)}, - {170, -1, -1, sizeof(::ProxyConnectionRequest)}, - {180, -1, -1, sizeof(::ProxyConnectionResponse)}, - {189, -1, -1, sizeof(::TemporaryConnectionRequest)}, - {197, -1, -1, sizeof(::TemporaryConnectionResponse)}, - {206, -1, -1, sizeof(::CloseTemporaryConnection)}, - {214, -1, -1, sizeof(::StreamPartitionInfo)}, - {225, -1, -1, sizeof(::ControlLayerInfo)}, - {235, -1, -1, sizeof(::NodeInfoRequest)}, - {243, 255, -1, sizeof(::NodeInfoResponse)}, -}; - -static const ::_pb::Message* const file_default_instances[] = { + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::MessageID)}, + {15, sizeof(::MessageRef)}, + {22, sizeof(::StreamMessage)}, + {41, sizeof(::ContentMessage)}, + {54, sizeof(::GroupKeyRequest)}, + {65, sizeof(::GroupKeyResponse)}, + {74, sizeof(::GroupKey)}, + {81, sizeof(::StreamPartHandshakeRequest)}, + {94, sizeof(::StreamPartHandshakeResponse)}, + {103, sizeof(::InterleaveRequest)}, + {108, sizeof(::InterleaveResponse)}, + {113, sizeof(::LeaveStreamPartNotice)}, + {120, sizeof(::NeighborUpdate)}, + {129, sizeof(::ProxyConnectionRequest)}, + {136, sizeof(::ProxyConnectionResponse)}, + {141, sizeof(::TemporaryConnectionRequest)}, + {142, sizeof(::TemporaryConnectionResponse)}, + {147, sizeof(::CloseTemporaryConnection)}, + {148, sizeof(::StreamPartitionInfo)}, + {157, sizeof(::ControlLayerInfo)}, + {164, sizeof(::NodeInfoRequest)}, + {165, sizeof(::NodeInfoResponse)}, +}; +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::_MessageID_default_instance_._instance, &::_MessageRef_default_instance_._instance, &::_StreamMessage_default_instance_._instance, @@ -815,7 +870,8 @@ static const ::_pb::Message* const file_default_instances[] = { &::_NodeInfoRequest_default_instance_._instance, &::_NodeInfoResponse_default_instance_._instance, }; -const char descriptor_table_protodef_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n(packages/network/protos/NetworkRpc.pro" "to\032\033google/protobuf/empty.proto\032\031google/" "protobuf/any.proto\032 packages/dht/protos/" @@ -902,14 +958,14 @@ const char descriptor_table_protodef_packages_2fnetwork_2fprotos_2fNetworkRpc_2e "\022\020.NodeInfoRequest\032\021.NodeInfoResponseB\002H" "\002b\006proto3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_deps[3] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_deps[3] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_packages_2fdht_2fprotos_2fDhtRpc_2eproto, }; static ::absl::once_flag descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto = { false, false, 3369, @@ -922,95 +978,78 @@ const ::_pbi::DescriptorTable descriptor_table_packages_2fnetwork_2fprotos_2fNet schemas, file_default_instances, TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto::offsets, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, file_level_service_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter() { - return &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto(&descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto); -const ::google::protobuf::EnumDescriptor* ContentType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ContentType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto); return file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t ContentType_internal_data_[] = { 131072u, 0u, }; -bool ContentType_IsValid(int value) { - return 0 <= value && value <= 1; -} -const ::google::protobuf::EnumDescriptor* EncryptionType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL EncryptionType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto); return file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[1]; } PROTOBUF_CONSTINIT const uint32_t EncryptionType_internal_data_[] = { 131072u, 0u, }; -bool EncryptionType_IsValid(int value) { - return 0 <= value && value <= 1; -} -const ::google::protobuf::EnumDescriptor* SignatureType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SignatureType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto); return file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[2]; } PROTOBUF_CONSTINIT const uint32_t SignatureType_internal_data_[] = { 196608u, 0u, }; -bool SignatureType_IsValid(int value) { - return 0 <= value && value <= 2; -} -const ::google::protobuf::EnumDescriptor* ProxyDirection_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ProxyDirection_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto); return file_level_enum_descriptors_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[3]; } PROTOBUF_CONSTINIT const uint32_t ProxyDirection_internal_data_[] = { 131072u, 0u, }; -bool ProxyDirection_IsValid(int value) { - return 0 <= value && value <= 1; -} // =================================================================== class MessageID::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(MessageID, _impl_._has_bits_); }; -MessageID::MessageID(::google::protobuf::Arena* arena) +MessageID::MessageID(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, MessageID_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:MessageID) } -inline PROTOBUF_NDEBUG_INLINE MessageID::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : streamid_(arena, from.streamid_), +PROTOBUF_NDEBUG_INLINE MessageID::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::MessageID& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + streamid_(arena, from.streamid_), publisherid_(arena, from.publisherid_), - messagechainid_(arena, from.messagechainid_), - _cached_size_{0} {} + messagechainid_(arena, from.messagechainid_) {} MessageID::MessageID( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MessageID& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, MessageID_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE MessageID* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); - ::memcpy(reinterpret_cast(&_impl_) + + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, timestamp_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, timestamp_), offsetof(Impl_, sequencenumber_) - offsetof(Impl_, timestamp_) + @@ -1018,17 +1057,17 @@ MessageID::MessageID( // @@protoc_insertion_point(copy_constructor:MessageID) } -inline PROTOBUF_NDEBUG_INLINE MessageID::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : streamid_(arena), +PROTOBUF_NDEBUG_INLINE MessageID::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + streamid_(arena), publisherid_(arena), - messagechainid_(arena), - _cached_size_{0} {} + messagechainid_(arena) {} -inline void MessageID::SharedCtor(::_pb::Arena* arena) { +inline void MessageID::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, timestamp_), 0, offsetof(Impl_, sequencenumber_) - @@ -1037,53 +1076,179 @@ inline void MessageID::SharedCtor(::_pb::Arena* arena) { } MessageID::~MessageID() { // @@protoc_insertion_point(destructor:MessageID) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void MessageID::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.streamid_.Destroy(); - _impl_.publisherid_.Destroy(); - _impl_.messagechainid_.Destroy(); - _impl_.~Impl_(); +inline void MessageID::SharedDtor(MessageLite& self) { + MessageID& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.streamid_.Destroy(); + this_._impl_.publisherid_.Destroy(); + this_._impl_.messagechainid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL MessageID::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) MessageID(arena); +} +constexpr auto MessageID::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(MessageID), + alignof(MessageID)); +} +constexpr auto MessageID::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_MessageID_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &MessageID::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &MessageID::SharedDtor, + static_cast(&MessageID::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(MessageID, _impl_._cached_size_), + false, + }, + &MessageID::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* MessageID::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void MessageID::InternalSwap(MessageID* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull MessageID_class_data_ = + MessageID::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +MessageID::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&MessageID_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(MessageID_class_data_.tc_table); + return MessageID_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 6, 0, 40, 2> +MessageID::_table_ = { + { + PROTOBUF_FIELD_OFFSET(MessageID, _impl_._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 + MessageID_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::MessageID>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string streamId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(MessageID, _impl_.streamid_)}}, + // int32 streamPartition = 2; + {::_pbi::TcParser::FastV32S1, + {16, 4, 0, + PROTOBUF_FIELD_OFFSET(MessageID, _impl_.streampartition_)}}, + // int64 timestamp = 3; + {::_pbi::TcParser::FastV64S1, + {24, 3, 0, + PROTOBUF_FIELD_OFFSET(MessageID, _impl_.timestamp_)}}, + // int32 sequenceNumber = 4; + {::_pbi::TcParser::FastV32S1, + {32, 5, 0, + PROTOBUF_FIELD_OFFSET(MessageID, _impl_.sequencenumber_)}}, + // bytes publisherId = 5; + {::_pbi::TcParser::FastBS1, + {42, 1, 0, + PROTOBUF_FIELD_OFFSET(MessageID, _impl_.publisherid_)}}, + // string messageChainId = 6; + {::_pbi::TcParser::FastUS1, + {50, 2, 0, + PROTOBUF_FIELD_OFFSET(MessageID, _impl_.messagechainid_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string streamId = 1; + {PROTOBUF_FIELD_OFFSET(MessageID, _impl_.streamid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 streamPartition = 2; + {PROTOBUF_FIELD_OFFSET(MessageID, _impl_.streampartition_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + // int64 timestamp = 3; + {PROTOBUF_FIELD_OFFSET(MessageID, _impl_.timestamp_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + // int32 sequenceNumber = 4; + {PROTOBUF_FIELD_OFFSET(MessageID, _impl_.sequencenumber_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + // bytes publisherId = 5; + {PROTOBUF_FIELD_OFFSET(MessageID, _impl_.publisherid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // string messageChainId = 6; + {PROTOBUF_FIELD_OFFSET(MessageID, _impl_.messagechainid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\11\10\0\0\0\0\16\0" + "MessageID" + "streamId" + "messageChainId" + }}, +}; +void MessageID::InternalSwap(MessageID* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata MessageID::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[0]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class MessageRef::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(MessageRef, _impl_._has_bits_); }; -MessageRef::MessageRef(::google::protobuf::Arena* arena) +MessageRef::MessageRef(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, MessageRef_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:MessageRef) } MessageRef::MessageRef( - ::google::protobuf::Arena* arena, const MessageRef& from) - : MessageRef(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MessageRef& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, MessageRef_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE MessageRef::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE MessageRef::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void MessageRef::SharedCtor(::_pb::Arena* arena) { +inline void MessageRef::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, timestamp_), 0, offsetof(Impl_, sequencenumber_) - @@ -1092,64 +1257,121 @@ inline void MessageRef::SharedCtor(::_pb::Arena* arena) { } MessageRef::~MessageRef() { // @@protoc_insertion_point(destructor:MessageRef) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void MessageRef::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void MessageRef::SharedDtor(MessageLite& self) { + MessageRef& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL MessageRef::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) MessageRef(arena); +} +constexpr auto MessageRef::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(MessageRef), + alignof(MessageRef)); +} +constexpr auto MessageRef::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_MessageRef_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &MessageRef::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &MessageRef::SharedDtor, + static_cast(&MessageRef::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(MessageRef, _impl_._cached_size_), + false, + }, + &MessageRef::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* MessageRef::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void MessageRef::InternalSwap(MessageRef* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull MessageRef_class_data_ = + MessageRef::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +MessageRef::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&MessageRef_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(MessageRef_class_data_.tc_table); + return MessageRef_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> +MessageRef::_table_ = { + { + PROTOBUF_FIELD_OFFSET(MessageRef, _impl_._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 + MessageRef_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::MessageRef>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 sequenceNumber = 2; + {::_pbi::TcParser::FastV32S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(MessageRef, _impl_.sequencenumber_)}}, + // int64 timestamp = 1; + {::_pbi::TcParser::FastV64S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(MessageRef, _impl_.timestamp_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int64 timestamp = 1; + {PROTOBUF_FIELD_OFFSET(MessageRef, _impl_.timestamp_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + // int32 sequenceNumber = 2; + {PROTOBUF_FIELD_OFFSET(MessageRef, _impl_.sequencenumber_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + }}, +}; +void MessageRef::InternalSwap(MessageRef* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata MessageRef::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StreamMessage::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_._has_bits_); static constexpr ::int32_t kOneofCaseOffset = - PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_._oneof_case_); - static const ::MessageID& messageid(const StreamMessage* msg); - static void set_has_messageid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::MessageRef& previousmessageref(const StreamMessage* msg); - static void set_has_previousmessageref(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::ContentMessage& contentmessage(const StreamMessage* msg); - static const ::GroupKeyRequest& groupkeyrequest(const StreamMessage* msg); - static const ::GroupKeyResponse& groupkeyresponse(const StreamMessage* msg); + PROTOBUF_FIELD_OFFSET(::StreamMessage, _impl_._oneof_case_); }; -const ::MessageID& StreamMessage::_Internal::messageid(const StreamMessage* msg) { - return *msg->_impl_.messageid_; -} -const ::MessageRef& StreamMessage::_Internal::previousmessageref(const StreamMessage* msg) { - return *msg->_impl_.previousmessageref_; -} -const ::ContentMessage& StreamMessage::_Internal::contentmessage(const StreamMessage* msg) { - return *msg->_impl_.body_.contentmessage_; -} -const ::GroupKeyRequest& StreamMessage::_Internal::groupkeyrequest(const StreamMessage* msg) { - return *msg->_impl_.body_.groupkeyrequest_; -} -const ::GroupKeyResponse& StreamMessage::_Internal::groupkeyresponse(const StreamMessage* msg) { - return *msg->_impl_.body_.groupkeyresponse_; -} -void StreamMessage::set_allocated_contentmessage(::ContentMessage* contentmessage) { +void StreamMessage::set_allocated_contentmessage(::ContentMessage* PROTOBUF_NULLABLE contentmessage) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (contentmessage) { @@ -1162,7 +1384,7 @@ void StreamMessage::set_allocated_contentmessage(::ContentMessage* contentmessag } // @@protoc_insertion_point(field_set_allocated:StreamMessage.contentMessage) } -void StreamMessage::set_allocated_groupkeyrequest(::GroupKeyRequest* groupkeyrequest) { +void StreamMessage::set_allocated_groupkeyrequest(::GroupKeyRequest* PROTOBUF_NULLABLE groupkeyrequest) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (groupkeyrequest) { @@ -1175,7 +1397,7 @@ void StreamMessage::set_allocated_groupkeyrequest(::GroupKeyRequest* groupkeyreq } // @@protoc_insertion_point(field_set_allocated:StreamMessage.groupKeyRequest) } -void StreamMessage::set_allocated_groupkeyresponse(::GroupKeyResponse* groupkeyresponse) { +void StreamMessage::set_allocated_groupkeyresponse(::GroupKeyResponse* PROTOBUF_NULLABLE groupkeyresponse) { ::google::protobuf::Arena* message_arena = GetArena(); clear_body(); if (groupkeyresponse) { @@ -1188,14 +1410,19 @@ void StreamMessage::set_allocated_groupkeyresponse(::GroupKeyResponse* groupkeyr } // @@protoc_insertion_point(field_set_allocated:StreamMessage.groupKeyResponse) } -StreamMessage::StreamMessage(::google::protobuf::Arena* arena) +StreamMessage::StreamMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:StreamMessage) } -inline PROTOBUF_NDEBUG_INLINE StreamMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE StreamMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::StreamMessage& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, signature_(arena, from.signature_), @@ -1203,49 +1430,53 @@ inline PROTOBUF_NDEBUG_INLINE StreamMessage::Impl_::Impl_( _oneof_case_{from._oneof_case_[0]} {} StreamMessage::StreamMessage( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StreamMessage* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.messageid_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::MessageID>(arena, *from._impl_.messageid_) + _impl_.messageid_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.messageid_) : nullptr; - _impl_.previousmessageref_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::MessageRef>(arena, *from._impl_.previousmessageref_) + _impl_.previousmessageref_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.previousmessageref_) : nullptr; _impl_.signaturetype_ = from._impl_.signaturetype_; switch (body_case()) { case BODY_NOT_SET: break; case kContentMessage: - _impl_.body_.contentmessage_ = CreateMaybeMessage<::ContentMessage>(arena, *from._impl_.body_.contentmessage_); + _impl_.body_.contentmessage_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.contentmessage_); break; case kGroupKeyRequest: - _impl_.body_.groupkeyrequest_ = CreateMaybeMessage<::GroupKeyRequest>(arena, *from._impl_.body_.groupkeyrequest_); + _impl_.body_.groupkeyrequest_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.groupkeyrequest_); break; case kGroupKeyResponse: - _impl_.body_.groupkeyresponse_ = CreateMaybeMessage<::GroupKeyResponse>(arena, *from._impl_.body_.groupkeyresponse_); + _impl_.body_.groupkeyresponse_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_.groupkeyresponse_); break; } // @@protoc_insertion_point(copy_constructor:StreamMessage) } -inline PROTOBUF_NDEBUG_INLINE StreamMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE StreamMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, signature_(arena), body_{}, _oneof_case_{} {} -inline void StreamMessage::SharedCtor(::_pb::Arena* arena) { +inline void StreamMessage::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, messageid_), 0, offsetof(Impl_, signaturetype_) - @@ -1254,39 +1485,49 @@ inline void StreamMessage::SharedCtor(::_pb::Arena* arena) { } StreamMessage::~StreamMessage() { // @@protoc_insertion_point(destructor:StreamMessage) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); -} -inline void StreamMessage::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.signature_.Destroy(); - delete _impl_.messageid_; - delete _impl_.previousmessageref_; - if (has_body()) { - clear_body(); + SharedDtor(*this); +} +inline void StreamMessage::SharedDtor(MessageLite& self) { + StreamMessage& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); } - _impl_.~Impl_(); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.signature_.Destroy(); + delete this_._impl_.messageid_; + delete this_._impl_.previousmessageref_; + if (this_.has_body()) { + this_.clear_body(); + } + this_._impl_.~Impl_(); } void StreamMessage::clear_body() { // @@protoc_insertion_point(one_of_clear_start:StreamMessage) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); switch (body_case()) { case kContentMessage: { if (GetArena() == nullptr) { delete _impl_.body_.contentmessage_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.contentmessage_); } break; } case kGroupKeyRequest: { if (GetArena() == nullptr) { delete _impl_.body_.groupkeyrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.groupkeyrequest_); } break; } case kGroupKeyResponse: { if (GetArena() == nullptr) { delete _impl_.body_.groupkeyresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.groupkeyresponse_); } break; } @@ -1298,66 +1539,168 @@ void StreamMessage::clear_body() { } -::_pbi::CachedSize* StreamMessage::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL StreamMessage::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StreamMessage(arena); +} +constexpr auto StreamMessage::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(StreamMessage), + alignof(StreamMessage)); +} +constexpr auto StreamMessage::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StreamMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StreamMessage::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StreamMessage::SharedDtor, + static_cast(&StreamMessage::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_._cached_size_), + false, + }, + &StreamMessage::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -void StreamMessage::InternalSwap(StreamMessage* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StreamMessage_class_data_ = + StreamMessage::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StreamMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StreamMessage_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StreamMessage_class_data_.tc_table); + return StreamMessage_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 7, 5, 0, 2> +StreamMessage::_table_ = { + { + PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_._has_bits_), + 0, // no _extensions_ + 7, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967168, // skipmap + offsetof(decltype(_table_), field_entries), + 7, // num_field_entries + 5, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + StreamMessage_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::StreamMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .SignatureType signatureType = 4; + {::_pbi::TcParser::FastV32S1, + {32, 3, 0, + PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.signaturetype_)}}, + // .MessageID messageId = 1; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.messageid_)}}, + // optional .MessageRef previousMessageRef = 2; + {::_pbi::TcParser::FastMtS1, + {18, 2, 1, + PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.previousmessageref_)}}, + // bytes signature = 3; + {::_pbi::TcParser::FastBS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.signature_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .MessageID messageId = 1; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.messageid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .MessageRef previousMessageRef = 2; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.previousmessageref_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bytes signature = 3; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.signature_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .SignatureType signatureType = 4; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.signaturetype_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .ContentMessage contentMessage = 5; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.body_.contentmessage_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .GroupKeyRequest groupKeyRequest = 6; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.body_.groupkeyrequest_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .GroupKeyResponse groupKeyResponse = 7; + {PROTOBUF_FIELD_OFFSET(StreamMessage, _impl_.body_.groupkeyresponse_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::MessageID>()}, + {::_pbi::TcParser::GetTable<::MessageRef>()}, + {::_pbi::TcParser::GetTable<::ContentMessage>()}, + {::_pbi::TcParser::GetTable<::GroupKeyRequest>()}, + {::_pbi::TcParser::GetTable<::GroupKeyResponse>()}, + }}, + {{ + }}, +}; +void StreamMessage::InternalSwap(StreamMessage* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata StreamMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ContentMessage::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_._has_bits_); - static void set_has_groupkeyid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::GroupKey& newgroupkey(const ContentMessage* msg); - static void set_has_newgroupkey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_._has_bits_); }; -const ::GroupKey& ContentMessage::_Internal::newgroupkey(const ContentMessage* msg) { - return *msg->_impl_.newgroupkey_; -} -ContentMessage::ContentMessage(::google::protobuf::Arena* arena) +ContentMessage::ContentMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ContentMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ContentMessage) } -inline PROTOBUF_NDEBUG_INLINE ContentMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE ContentMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::ContentMessage& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, content_(arena, from.content_), groupkeyid_(arena, from.groupkeyid_) {} ContentMessage::ContentMessage( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ContentMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ContentMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ContentMessage* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.newgroupkey_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::GroupKey>(arena, *from._impl_.newgroupkey_) + _impl_.newgroupkey_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.newgroupkey_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + + ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, contenttype_), - reinterpret_cast(&from._impl_) + + reinterpret_cast(&from._impl_) + offsetof(Impl_, contenttype_), offsetof(Impl_, encryptiontype_) - offsetof(Impl_, contenttype_) + @@ -1365,16 +1708,16 @@ ContentMessage::ContentMessage( // @@protoc_insertion_point(copy_constructor:ContentMessage) } -inline PROTOBUF_NDEBUG_INLINE ContentMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ContentMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, content_(arena), groupkeyid_(arena) {} -inline void ContentMessage::SharedCtor(::_pb::Arena* arena) { +inline void ContentMessage::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, newgroupkey_), 0, offsetof(Impl_, encryptiontype_) - @@ -1383,251 +1726,702 @@ inline void ContentMessage::SharedCtor(::_pb::Arena* arena) { } ContentMessage::~ContentMessage() { // @@protoc_insertion_point(destructor:ContentMessage) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ContentMessage::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.content_.Destroy(); - _impl_.groupkeyid_.Destroy(); - delete _impl_.newgroupkey_; - _impl_.~Impl_(); +inline void ContentMessage::SharedDtor(MessageLite& self) { + ContentMessage& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.content_.Destroy(); + this_._impl_.groupkeyid_.Destroy(); + delete this_._impl_.newgroupkey_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ContentMessage::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ContentMessage(arena); +} +constexpr auto ContentMessage::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ContentMessage), + alignof(ContentMessage)); +} +constexpr auto ContentMessage::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ContentMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ContentMessage::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ContentMessage::SharedDtor, + static_cast(&ContentMessage::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_._cached_size_), + false, + }, + &ContentMessage::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ContentMessage::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ContentMessage::InternalSwap(ContentMessage* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ContentMessage_class_data_ = + ContentMessage::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ContentMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ContentMessage_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ContentMessage_class_data_.tc_table); + return ContentMessage_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 1, 33, 2> +ContentMessage::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ContentMessage, _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), + ContentMessage_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ContentMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bytes content = 1; + {::_pbi::TcParser::FastBS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.content_)}}, + // .ContentType contentType = 2; + {::_pbi::TcParser::FastV32S1, + {16, 3, 0, + PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.contenttype_)}}, + // .EncryptionType encryptionType = 3; + {::_pbi::TcParser::FastV32S1, + {24, 4, 0, + PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.encryptiontype_)}}, + // optional string groupKeyId = 4; + {::_pbi::TcParser::FastUS1, + {34, 1, 0, + PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.groupkeyid_)}}, + // optional .GroupKey newGroupKey = 5; + {::_pbi::TcParser::FastMtS1, + {42, 2, 0, + PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.newgroupkey_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // bytes content = 1; + {PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.content_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // .ContentType contentType = 2; + {PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.contenttype_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .EncryptionType encryptionType = 3; + {PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.encryptiontype_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // optional string groupKeyId = 4; + {PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.groupkeyid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .GroupKey newGroupKey = 5; + {PROTOBUF_FIELD_OFFSET(ContentMessage, _impl_.newgroupkey_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::GroupKey>()}, + }}, + {{ + "\16\0\0\0\12\0\0\0" + "ContentMessage" + "groupKeyId" + }}, +}; +void ContentMessage::InternalSwap(ContentMessage* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ContentMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[3]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GroupKeyRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_._has_bits_); }; -GroupKeyRequest::GroupKeyRequest(::google::protobuf::Arena* arena) +GroupKeyRequest::GroupKeyRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GroupKeyRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:GroupKeyRequest) } -inline PROTOBUF_NDEBUG_INLINE GroupKeyRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : groupkeyids_{visibility, arena, from.groupkeyids_}, +PROTOBUF_NDEBUG_INLINE GroupKeyRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::GroupKeyRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + groupkeyids_{visibility, arena, from.groupkeyids_}, requestid_(arena, from.requestid_), recipientid_(arena, from.recipientid_), - rsapublickey_(arena, from.rsapublickey_), - _cached_size_{0} {} + rsapublickey_(arena, from.rsapublickey_) {} GroupKeyRequest::GroupKeyRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GroupKeyRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GroupKeyRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE GroupKeyRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:GroupKeyRequest) } -inline PROTOBUF_NDEBUG_INLINE GroupKeyRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : groupkeyids_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE GroupKeyRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + groupkeyids_{visibility, arena}, requestid_(arena), recipientid_(arena), - rsapublickey_(arena), - _cached_size_{0} {} + rsapublickey_(arena) {} -inline void GroupKeyRequest::SharedCtor(::_pb::Arena* arena) { +inline void GroupKeyRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } GroupKeyRequest::~GroupKeyRequest() { // @@protoc_insertion_point(destructor:GroupKeyRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void GroupKeyRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.recipientid_.Destroy(); - _impl_.rsapublickey_.Destroy(); - _impl_.~Impl_(); +inline void GroupKeyRequest::SharedDtor(MessageLite& self) { + GroupKeyRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.recipientid_.Destroy(); + this_._impl_.rsapublickey_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL GroupKeyRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) GroupKeyRequest(arena); +} +constexpr auto GroupKeyRequest::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.groupkeyids_) + + decltype(GroupKeyRequest::_impl_.groupkeyids_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(GroupKeyRequest), alignof(GroupKeyRequest), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&GroupKeyRequest::PlacementNew_, + sizeof(GroupKeyRequest), + alignof(GroupKeyRequest)); + } } - -::_pbi::CachedSize* GroupKeyRequest::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto GroupKeyRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_GroupKeyRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GroupKeyRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GroupKeyRequest::SharedDtor, + static_cast(&GroupKeyRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_._cached_size_), + false, + }, + &GroupKeyRequest::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -void GroupKeyRequest::InternalSwap(GroupKeyRequest* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull GroupKeyRequest_class_data_ = + GroupKeyRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +GroupKeyRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&GroupKeyRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(GroupKeyRequest_class_data_.tc_table); + return GroupKeyRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 44, 2> +GroupKeyRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_._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 + GroupKeyRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::GroupKeyRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated string groupKeyIds = 4; + {::_pbi::TcParser::FastUR1, + {34, 0, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.groupkeyids_)}}, + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.requestid_)}}, + // bytes recipientId = 2; + {::_pbi::TcParser::FastBS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.recipientid_)}}, + // bytes rsaPublicKey = 3; + {::_pbi::TcParser::FastBS1, + {26, 3, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.rsapublickey_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bytes recipientId = 2; + {PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.recipientid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // bytes rsaPublicKey = 3; + {PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.rsapublickey_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // repeated string groupKeyIds = 4; + {PROTOBUF_FIELD_OFFSET(GroupKeyRequest, _impl_.groupkeyids_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, + }}, + // no aux_entries + {{ + "\17\11\0\0\13\0\0\0" + "GroupKeyRequest" + "requestId" + "groupKeyIds" + }}, +}; +void GroupKeyRequest::InternalSwap(GroupKeyRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata GroupKeyRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[4]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GroupKeyResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_._has_bits_); }; -GroupKeyResponse::GroupKeyResponse(::google::protobuf::Arena* arena) +GroupKeyResponse::GroupKeyResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GroupKeyResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:GroupKeyResponse) } -inline PROTOBUF_NDEBUG_INLINE GroupKeyResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : groupkeys_{visibility, arena, from.groupkeys_}, +PROTOBUF_NDEBUG_INLINE GroupKeyResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::GroupKeyResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + groupkeys_{visibility, arena, from.groupkeys_}, requestid_(arena, from.requestid_), - recipientid_(arena, from.recipientid_), - _cached_size_{0} {} + recipientid_(arena, from.recipientid_) {} GroupKeyResponse::GroupKeyResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GroupKeyResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GroupKeyResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE GroupKeyResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:GroupKeyResponse) } -inline PROTOBUF_NDEBUG_INLINE GroupKeyResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : groupkeys_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE GroupKeyResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + groupkeys_{visibility, arena}, requestid_(arena), - recipientid_(arena), - _cached_size_{0} {} + recipientid_(arena) {} -inline void GroupKeyResponse::SharedCtor(::_pb::Arena* arena) { +inline void GroupKeyResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } GroupKeyResponse::~GroupKeyResponse() { // @@protoc_insertion_point(destructor:GroupKeyResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); +} +inline void GroupKeyResponse::SharedDtor(MessageLite& self) { + GroupKeyResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.recipientid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL GroupKeyResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) GroupKeyResponse(arena); +} +constexpr auto GroupKeyResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.groupkeys_) + + decltype(GroupKeyResponse::_impl_.groupkeys_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(GroupKeyResponse), alignof(GroupKeyResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&GroupKeyResponse::PlacementNew_, + sizeof(GroupKeyResponse), + alignof(GroupKeyResponse)); + } } -inline void GroupKeyResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.recipientid_.Destroy(); - _impl_.~Impl_(); +constexpr auto GroupKeyResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_GroupKeyResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GroupKeyResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GroupKeyResponse::SharedDtor, + static_cast(&GroupKeyResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_._cached_size_), + false, + }, + &GroupKeyResponse::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* GroupKeyResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void GroupKeyResponse::InternalSwap(GroupKeyResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull GroupKeyResponse_class_data_ = + GroupKeyResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +GroupKeyResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&GroupKeyResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(GroupKeyResponse_class_data_.tc_table); + return GroupKeyResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 34, 2> +GroupKeyResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _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), + GroupKeyResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::GroupKeyResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string requestId = 1; + {::_pbi::TcParser::FastUS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.requestid_)}}, + // bytes recipientId = 2; + {::_pbi::TcParser::FastBS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.recipientid_)}}, + // repeated .GroupKey groupKeys = 3; + {::_pbi::TcParser::FastMtR1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.groupkeys_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string requestId = 1; + {PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bytes recipientId = 2; + {PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.recipientid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // repeated .GroupKey groupKeys = 3; + {PROTOBUF_FIELD_OFFSET(GroupKeyResponse, _impl_.groupkeys_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::GroupKey>()}, + }}, + {{ + "\20\11\0\0\0\0\0\0" + "GroupKeyResponse" + "requestId" + }}, +}; +void GroupKeyResponse::InternalSwap(GroupKeyResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata GroupKeyResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[5]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GroupKey::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(GroupKey, _impl_._has_bits_); }; -GroupKey::GroupKey(::google::protobuf::Arena* arena) +GroupKey::GroupKey(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GroupKey_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:GroupKey) } -inline PROTOBUF_NDEBUG_INLINE GroupKey::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : id_(arena, from.id_), - data_(arena, from.data_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE GroupKey::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::GroupKey& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + id_(arena, from.id_), + data_(arena, from.data_) {} GroupKey::GroupKey( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GroupKey& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GroupKey_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE GroupKey* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:GroupKey) } -inline PROTOBUF_NDEBUG_INLINE GroupKey::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : id_(arena), - data_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE GroupKey::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + id_(arena), + data_(arena) {} -inline void GroupKey::SharedCtor(::_pb::Arena* arena) { +inline void GroupKey::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } GroupKey::~GroupKey() { // @@protoc_insertion_point(destructor:GroupKey) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void GroupKey::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.id_.Destroy(); - _impl_.data_.Destroy(); - _impl_.~Impl_(); +inline void GroupKey::SharedDtor(MessageLite& self) { + GroupKey& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.id_.Destroy(); + this_._impl_.data_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL GroupKey::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) GroupKey(arena); +} +constexpr auto GroupKey::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(GroupKey), + alignof(GroupKey)); +} +constexpr auto GroupKey::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_GroupKey_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GroupKey::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GroupKey::SharedDtor, + static_cast(&GroupKey::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GroupKey, _impl_._cached_size_), + false, + }, + &GroupKey::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* GroupKey::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void GroupKey::InternalSwap(GroupKey* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull GroupKey_class_data_ = + GroupKey::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +GroupKey::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&GroupKey_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(GroupKey_class_data_.tc_table); + return GroupKey_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 19, 2> +GroupKey::_table_ = { + { + PROTOBUF_FIELD_OFFSET(GroupKey, _impl_._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 + GroupKey_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::GroupKey>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bytes data = 2; + {::_pbi::TcParser::FastBS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(GroupKey, _impl_.data_)}}, + // string id = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(GroupKey, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string id = 1; + {PROTOBUF_FIELD_OFFSET(GroupKey, _impl_.id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bytes data = 2; + {PROTOBUF_FIELD_OFFSET(GroupKey, _impl_.data_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\10\2\0\0\0\0\0\0" + "GroupKey" + "id" + }}, +}; +void GroupKey::InternalSwap(GroupKey* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata GroupKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[6]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StreamPartHandshakeRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_._has_bits_); - static void set_has_concurrenthandshakenodeid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_interleavenodeid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_._has_bits_); }; -StreamPartHandshakeRequest::StreamPartHandshakeRequest(::google::protobuf::Arena* arena) +StreamPartHandshakeRequest::StreamPartHandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamPartHandshakeRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:StreamPartHandshakeRequest) } -inline PROTOBUF_NDEBUG_INLINE StreamPartHandshakeRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE StreamPartHandshakeRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::StreamPartHandshakeRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, neighbornodeids_{visibility, arena, from.neighbornodeids_}, @@ -1637,20 +2431,24 @@ inline PROTOBUF_NDEBUG_INLINE StreamPartHandshakeRequest::Impl_::Impl_( interleavenodeid_(arena, from.interleavenodeid_) {} StreamPartHandshakeRequest::StreamPartHandshakeRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamPartHandshakeRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamPartHandshakeRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StreamPartHandshakeRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:StreamPartHandshakeRequest) } -inline PROTOBUF_NDEBUG_INLINE StreamPartHandshakeRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE StreamPartHandshakeRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, neighbornodeids_{visibility, arena}, streampartid_(arena), @@ -1658,94 +2456,217 @@ inline PROTOBUF_NDEBUG_INLINE StreamPartHandshakeRequest::Impl_::Impl_( concurrenthandshakenodeid_(arena), interleavenodeid_(arena) {} -inline void StreamPartHandshakeRequest::SharedCtor(::_pb::Arena* arena) { +inline void StreamPartHandshakeRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } StreamPartHandshakeRequest::~StreamPartHandshakeRequest() { // @@protoc_insertion_point(destructor:StreamPartHandshakeRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void StreamPartHandshakeRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.streampartid_.Destroy(); - _impl_.requestid_.Destroy(); - _impl_.concurrenthandshakenodeid_.Destroy(); - _impl_.interleavenodeid_.Destroy(); - _impl_.~Impl_(); +inline void StreamPartHandshakeRequest::SharedDtor(MessageLite& self) { + StreamPartHandshakeRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.streampartid_.Destroy(); + this_._impl_.requestid_.Destroy(); + this_._impl_.concurrenthandshakenodeid_.Destroy(); + this_._impl_.interleavenodeid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL StreamPartHandshakeRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StreamPartHandshakeRequest(arena); +} +constexpr auto StreamPartHandshakeRequest::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.neighbornodeids_) + + decltype(StreamPartHandshakeRequest::_impl_.neighbornodeids_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(StreamPartHandshakeRequest), alignof(StreamPartHandshakeRequest), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&StreamPartHandshakeRequest::PlacementNew_, + sizeof(StreamPartHandshakeRequest), + alignof(StreamPartHandshakeRequest)); + } } - -::_pbi::CachedSize* StreamPartHandshakeRequest::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto StreamPartHandshakeRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StreamPartHandshakeRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StreamPartHandshakeRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StreamPartHandshakeRequest::SharedDtor, + static_cast(&StreamPartHandshakeRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_._cached_size_), + false, + }, + &StreamPartHandshakeRequest::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -void StreamPartHandshakeRequest::InternalSwap(StreamPartHandshakeRequest* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StreamPartHandshakeRequest_class_data_ = + StreamPartHandshakeRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StreamPartHandshakeRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StreamPartHandshakeRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StreamPartHandshakeRequest_class_data_.tc_table); + return StreamPartHandshakeRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 0, 56, 2> +StreamPartHandshakeRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + StreamPartHandshakeRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::StreamPartHandshakeRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string streamPartId = 1; + {::_pbi::TcParser::FastUS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.streampartid_)}}, + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 2, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.requestid_)}}, + // optional bytes concurrentHandshakeNodeId = 3; + {::_pbi::TcParser::FastBS1, + {26, 3, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.concurrenthandshakenodeid_)}}, + // repeated bytes neighborNodeIds = 4; + {::_pbi::TcParser::FastBR1, + {34, 0, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.neighbornodeids_)}}, + // optional bytes interleaveNodeId = 5; + {::_pbi::TcParser::FastBS1, + {42, 4, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.interleavenodeid_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string streamPartId = 1; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.streampartid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.requestid_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional bytes concurrentHandshakeNodeId = 3; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.concurrenthandshakenodeid_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + // repeated bytes neighborNodeIds = 4; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.neighbornodeids_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, + // optional bytes interleaveNodeId = 5; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeRequest, _impl_.interleavenodeid_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\32\14\11\0\0\0\0\0" + "StreamPartHandshakeRequest" + "streamPartId" + "requestId" + }}, +}; +void StreamPartHandshakeRequest::InternalSwap(StreamPartHandshakeRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata StreamPartHandshakeRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[7]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StreamPartHandshakeResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_._has_bits_); - static const ::dht::PeerDescriptor& interleavetargetdescriptor(const StreamPartHandshakeResponse* msg); - static void set_has_interleavetargetdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& StreamPartHandshakeResponse::_Internal::interleavetargetdescriptor(const StreamPartHandshakeResponse* msg) { - return *msg->_impl_.interleavetargetdescriptor_; -} void StreamPartHandshakeResponse::clear_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.interleavetargetdescriptor_ != nullptr) _impl_.interleavetargetdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -StreamPartHandshakeResponse::StreamPartHandshakeResponse(::google::protobuf::Arena* arena) +StreamPartHandshakeResponse::StreamPartHandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamPartHandshakeResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:StreamPartHandshakeResponse) } -inline PROTOBUF_NDEBUG_INLINE StreamPartHandshakeResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE StreamPartHandshakeResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::StreamPartHandshakeResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, requestid_(arena, from.requestid_) {} StreamPartHandshakeResponse::StreamPartHandshakeResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamPartHandshakeResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamPartHandshakeResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StreamPartHandshakeResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.interleavetargetdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.interleavetargetdescriptor_) + _impl_.interleavetargetdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.interleavetargetdescriptor_) : nullptr; _impl_.accepted_ = from._impl_.accepted_; // @@protoc_insertion_point(copy_constructor:StreamPartHandshakeResponse) } -inline PROTOBUF_NDEBUG_INLINE StreamPartHandshakeResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE StreamPartHandshakeResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, requestid_(arena) {} -inline void StreamPartHandshakeResponse::SharedCtor(::_pb::Arena* arena) { +inline void StreamPartHandshakeResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, interleavetargetdescriptor_), 0, offsetof(Impl_, accepted_) - @@ -1754,396 +2675,1069 @@ inline void StreamPartHandshakeResponse::SharedCtor(::_pb::Arena* arena) { } StreamPartHandshakeResponse::~StreamPartHandshakeResponse() { // @@protoc_insertion_point(destructor:StreamPartHandshakeResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void StreamPartHandshakeResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - delete _impl_.interleavetargetdescriptor_; - _impl_.~Impl_(); +inline void StreamPartHandshakeResponse::SharedDtor(MessageLite& self) { + StreamPartHandshakeResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + delete this_._impl_.interleavetargetdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL StreamPartHandshakeResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StreamPartHandshakeResponse(arena); +} +constexpr auto StreamPartHandshakeResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(StreamPartHandshakeResponse), + alignof(StreamPartHandshakeResponse)); +} +constexpr auto StreamPartHandshakeResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StreamPartHandshakeResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StreamPartHandshakeResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StreamPartHandshakeResponse::SharedDtor, + static_cast(&StreamPartHandshakeResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_._cached_size_), + false, + }, + &StreamPartHandshakeResponse::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* StreamPartHandshakeResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void StreamPartHandshakeResponse::InternalSwap(StreamPartHandshakeResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StreamPartHandshakeResponse_class_data_ = + StreamPartHandshakeResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StreamPartHandshakeResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StreamPartHandshakeResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StreamPartHandshakeResponse_class_data_.tc_table); + return StreamPartHandshakeResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 45, 2> +StreamPartHandshakeResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _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), + StreamPartHandshakeResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::StreamPartHandshakeResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // bool accepted = 1; + {::_pbi::TcParser::FastV8S1, + {8, 2, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_.accepted_)}}, + // string requestId = 2; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_.requestid_)}}, + // optional .dht.PeerDescriptor interleaveTargetDescriptor = 3; + {::_pbi::TcParser::FastMtS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_.interleavetargetdescriptor_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool accepted = 1; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_.accepted_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // string requestId = 2; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .dht.PeerDescriptor interleaveTargetDescriptor = 3; + {PROTOBUF_FIELD_OFFSET(StreamPartHandshakeResponse, _impl_.interleavetargetdescriptor_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\33\0\11\0\0\0\0\0" + "StreamPartHandshakeResponse" + "requestId" + }}, +}; +void StreamPartHandshakeResponse::InternalSwap(StreamPartHandshakeResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata StreamPartHandshakeResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[8]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class InterleaveRequest::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(InterleaveRequest, _impl_._has_bits_); - static const ::dht::PeerDescriptor& interleavetargetdescriptor(const InterleaveRequest* msg); - static void set_has_interleavetargetdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(InterleaveRequest, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& InterleaveRequest::_Internal::interleavetargetdescriptor(const InterleaveRequest* msg) { - return *msg->_impl_.interleavetargetdescriptor_; -} void InterleaveRequest::clear_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.interleavetargetdescriptor_ != nullptr) _impl_.interleavetargetdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -InterleaveRequest::InterleaveRequest(::google::protobuf::Arena* arena) +InterleaveRequest::InterleaveRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, InterleaveRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:InterleaveRequest) } -inline PROTOBUF_NDEBUG_INLINE InterleaveRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE InterleaveRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::InterleaveRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} InterleaveRequest::InterleaveRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const InterleaveRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, InterleaveRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE InterleaveRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.interleavetargetdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.interleavetargetdescriptor_) + _impl_.interleavetargetdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.interleavetargetdescriptor_) : nullptr; // @@protoc_insertion_point(copy_constructor:InterleaveRequest) } -inline PROTOBUF_NDEBUG_INLINE InterleaveRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE InterleaveRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void InterleaveRequest::SharedCtor(::_pb::Arena* arena) { +inline void InterleaveRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.interleavetargetdescriptor_ = {}; } InterleaveRequest::~InterleaveRequest() { // @@protoc_insertion_point(destructor:InterleaveRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void InterleaveRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - delete _impl_.interleavetargetdescriptor_; - _impl_.~Impl_(); +inline void InterleaveRequest::SharedDtor(MessageLite& self) { + InterleaveRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.interleavetargetdescriptor_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL InterleaveRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) InterleaveRequest(arena); +} +constexpr auto InterleaveRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(InterleaveRequest), + alignof(InterleaveRequest)); +} +constexpr auto InterleaveRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_InterleaveRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &InterleaveRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &InterleaveRequest::SharedDtor, + static_cast(&InterleaveRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(InterleaveRequest, _impl_._cached_size_), + false, + }, + &InterleaveRequest::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* InterleaveRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void InterleaveRequest::InternalSwap(InterleaveRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull InterleaveRequest_class_data_ = + InterleaveRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +InterleaveRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&InterleaveRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(InterleaveRequest_class_data_.tc_table); + return InterleaveRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +InterleaveRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(InterleaveRequest, _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), + InterleaveRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::InterleaveRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .dht.PeerDescriptor interleaveTargetDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(InterleaveRequest, _impl_.interleavetargetdescriptor_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.PeerDescriptor interleaveTargetDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(InterleaveRequest, _impl_.interleavetargetdescriptor_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + }}, +}; +void InterleaveRequest::InternalSwap(InterleaveRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata InterleaveRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[9]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class InterleaveResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(InterleaveResponse, _impl_._has_bits_); }; -InterleaveResponse::InterleaveResponse(::google::protobuf::Arena* arena) +InterleaveResponse::InterleaveResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, InterleaveResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:InterleaveResponse) } InterleaveResponse::InterleaveResponse( - ::google::protobuf::Arena* arena, const InterleaveResponse& from) - : InterleaveResponse(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const InterleaveResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, InterleaveResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE InterleaveResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE InterleaveResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void InterleaveResponse::SharedCtor(::_pb::Arena* arena) { +inline void InterleaveResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.accepted_ = {}; } InterleaveResponse::~InterleaveResponse() { // @@protoc_insertion_point(destructor:InterleaveResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void InterleaveResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void InterleaveResponse::SharedDtor(MessageLite& self) { + InterleaveResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL InterleaveResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) InterleaveResponse(arena); +} +constexpr auto InterleaveResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(InterleaveResponse), + alignof(InterleaveResponse)); +} +constexpr auto InterleaveResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_InterleaveResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &InterleaveResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &InterleaveResponse::SharedDtor, + static_cast(&InterleaveResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(InterleaveResponse, _impl_._cached_size_), + false, + }, + &InterleaveResponse::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* InterleaveResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void InterleaveResponse::InternalSwap(InterleaveResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull InterleaveResponse_class_data_ = + InterleaveResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +InterleaveResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&InterleaveResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(InterleaveResponse_class_data_.tc_table); + return InterleaveResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +InterleaveResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(InterleaveResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + InterleaveResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::InterleaveResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool accepted = 1; + {::_pbi::TcParser::FastV8S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(InterleaveResponse, _impl_.accepted_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool accepted = 1; + {PROTOBUF_FIELD_OFFSET(InterleaveResponse, _impl_.accepted_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; +void InterleaveResponse::InternalSwap(InterleaveResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata InterleaveResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[10]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class LeaveStreamPartNotice::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_._has_bits_); }; -LeaveStreamPartNotice::LeaveStreamPartNotice(::google::protobuf::Arena* arena) +LeaveStreamPartNotice::LeaveStreamPartNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LeaveStreamPartNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:LeaveStreamPartNotice) } -inline PROTOBUF_NDEBUG_INLINE LeaveStreamPartNotice::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : streampartid_(arena, from.streampartid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE LeaveStreamPartNotice::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::LeaveStreamPartNotice& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + streampartid_(arena, from.streampartid_) {} LeaveStreamPartNotice::LeaveStreamPartNotice( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LeaveStreamPartNotice& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, LeaveStreamPartNotice_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE LeaveStreamPartNotice* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.isentrypoint_ = from._impl_.isentrypoint_; // @@protoc_insertion_point(copy_constructor:LeaveStreamPartNotice) } -inline PROTOBUF_NDEBUG_INLINE LeaveStreamPartNotice::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : streampartid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE LeaveStreamPartNotice::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + streampartid_(arena) {} -inline void LeaveStreamPartNotice::SharedCtor(::_pb::Arena* arena) { +inline void LeaveStreamPartNotice::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.isentrypoint_ = {}; } LeaveStreamPartNotice::~LeaveStreamPartNotice() { // @@protoc_insertion_point(destructor:LeaveStreamPartNotice) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void LeaveStreamPartNotice::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.streampartid_.Destroy(); - _impl_.~Impl_(); +inline void LeaveStreamPartNotice::SharedDtor(MessageLite& self) { + LeaveStreamPartNotice& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.streampartid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL LeaveStreamPartNotice::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) LeaveStreamPartNotice(arena); +} +constexpr auto LeaveStreamPartNotice::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(LeaveStreamPartNotice), + alignof(LeaveStreamPartNotice)); +} +constexpr auto LeaveStreamPartNotice::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_LeaveStreamPartNotice_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LeaveStreamPartNotice::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LeaveStreamPartNotice::SharedDtor, + static_cast(&LeaveStreamPartNotice::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_._cached_size_), + false, + }, + &LeaveStreamPartNotice::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* LeaveStreamPartNotice::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void LeaveStreamPartNotice::InternalSwap(LeaveStreamPartNotice* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull LeaveStreamPartNotice_class_data_ = + LeaveStreamPartNotice::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +LeaveStreamPartNotice::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&LeaveStreamPartNotice_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(LeaveStreamPartNotice_class_data_.tc_table); + return LeaveStreamPartNotice_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 42, 2> +LeaveStreamPartNotice::_table_ = { + { + PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_._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 + LeaveStreamPartNotice_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::LeaveStreamPartNotice>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool isEntryPoint = 2; + {::_pbi::TcParser::FastV8S1, + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_.isentrypoint_)}}, + // string streamPartId = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_.streampartid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string streamPartId = 1; + {PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_.streampartid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool isEntryPoint = 2; + {PROTOBUF_FIELD_OFFSET(LeaveStreamPartNotice, _impl_.isentrypoint_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\25\14\0\0\0\0\0\0" + "LeaveStreamPartNotice" + "streamPartId" + }}, +}; +void LeaveStreamPartNotice::InternalSwap(LeaveStreamPartNotice* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata LeaveStreamPartNotice::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[11]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NeighborUpdate::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_._has_bits_); }; void NeighborUpdate::clear_neighbordescriptors() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.neighbordescriptors_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -NeighborUpdate::NeighborUpdate(::google::protobuf::Arena* arena) +NeighborUpdate::NeighborUpdate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, NeighborUpdate_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:NeighborUpdate) } -inline PROTOBUF_NDEBUG_INLINE NeighborUpdate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : neighbordescriptors_{visibility, arena, from.neighbordescriptors_}, - streampartid_(arena, from.streampartid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE NeighborUpdate::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::NeighborUpdate& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + neighbordescriptors_{visibility, arena, from.neighbordescriptors_}, + streampartid_(arena, from.streampartid_) {} NeighborUpdate::NeighborUpdate( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NeighborUpdate& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, NeighborUpdate_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE NeighborUpdate* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.removeme_ = from._impl_.removeme_; // @@protoc_insertion_point(copy_constructor:NeighborUpdate) } -inline PROTOBUF_NDEBUG_INLINE NeighborUpdate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : neighbordescriptors_{visibility, arena}, - streampartid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE NeighborUpdate::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + neighbordescriptors_{visibility, arena}, + streampartid_(arena) {} -inline void NeighborUpdate::SharedCtor(::_pb::Arena* arena) { +inline void NeighborUpdate::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.removeme_ = {}; } NeighborUpdate::~NeighborUpdate() { // @@protoc_insertion_point(destructor:NeighborUpdate) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void NeighborUpdate::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.streampartid_.Destroy(); - _impl_.~Impl_(); +inline void NeighborUpdate::SharedDtor(MessageLite& self) { + NeighborUpdate& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.streampartid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL NeighborUpdate::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) NeighborUpdate(arena); +} +constexpr auto NeighborUpdate::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.neighbordescriptors_) + + decltype(NeighborUpdate::_impl_.neighbordescriptors_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(NeighborUpdate), alignof(NeighborUpdate), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&NeighborUpdate::PlacementNew_, + sizeof(NeighborUpdate), + alignof(NeighborUpdate)); + } } - -::_pbi::CachedSize* NeighborUpdate::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto NeighborUpdate::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_NeighborUpdate_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &NeighborUpdate::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &NeighborUpdate::SharedDtor, + static_cast(&NeighborUpdate::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_._cached_size_), + false, + }, + &NeighborUpdate::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -void NeighborUpdate::InternalSwap(NeighborUpdate* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull NeighborUpdate_class_data_ = + NeighborUpdate::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +NeighborUpdate::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&NeighborUpdate_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(NeighborUpdate_class_data_.tc_table); + return NeighborUpdate_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 1, 35, 2> +NeighborUpdate::_table_ = { + { + PROTOBUF_FIELD_OFFSET(NeighborUpdate, _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), + NeighborUpdate_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::NeighborUpdate>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string streamPartId = 1; + {::_pbi::TcParser::FastUS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.streampartid_)}}, + // bool removeMe = 2; + {::_pbi::TcParser::FastV8S1, + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.removeme_)}}, + // repeated .dht.PeerDescriptor neighborDescriptors = 3; + {::_pbi::TcParser::FastMtR1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.neighbordescriptors_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string streamPartId = 1; + {PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.streampartid_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool removeMe = 2; + {PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.removeme_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // repeated .dht.PeerDescriptor neighborDescriptors = 3; + {PROTOBUF_FIELD_OFFSET(NeighborUpdate, _impl_.neighbordescriptors_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\16\14\0\0\0\0\0\0" + "NeighborUpdate" + "streamPartId" + }}, +}; +void NeighborUpdate::InternalSwap(NeighborUpdate* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata NeighborUpdate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[12]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ProxyConnectionRequest::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_._has_bits_); }; -ProxyConnectionRequest::ProxyConnectionRequest(::google::protobuf::Arena* arena) +ProxyConnectionRequest::ProxyConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ProxyConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ProxyConnectionRequest) } -inline PROTOBUF_NDEBUG_INLINE ProxyConnectionRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : userid_(arena, from.userid_), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ProxyConnectionRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::ProxyConnectionRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + userid_(arena, from.userid_) {} ProxyConnectionRequest::ProxyConnectionRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ProxyConnectionRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ProxyConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ProxyConnectionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.direction_ = from._impl_.direction_; // @@protoc_insertion_point(copy_constructor:ProxyConnectionRequest) } -inline PROTOBUF_NDEBUG_INLINE ProxyConnectionRequest::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : userid_(arena), - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ProxyConnectionRequest::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + userid_(arena) {} -inline void ProxyConnectionRequest::SharedCtor(::_pb::Arena* arena) { +inline void ProxyConnectionRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.direction_ = {}; } ProxyConnectionRequest::~ProxyConnectionRequest() { // @@protoc_insertion_point(destructor:ProxyConnectionRequest) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ProxyConnectionRequest::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.userid_.Destroy(); - _impl_.~Impl_(); +inline void ProxyConnectionRequest::SharedDtor(MessageLite& self) { + ProxyConnectionRequest& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.userid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ProxyConnectionRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ProxyConnectionRequest(arena); +} +constexpr auto ProxyConnectionRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ProxyConnectionRequest), + alignof(ProxyConnectionRequest)); +} +constexpr auto ProxyConnectionRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ProxyConnectionRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ProxyConnectionRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ProxyConnectionRequest::SharedDtor, + static_cast(&ProxyConnectionRequest::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_._cached_size_), + false, + }, + &ProxyConnectionRequest::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ProxyConnectionRequest::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ProxyConnectionRequest::InternalSwap(ProxyConnectionRequest* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ProxyConnectionRequest_class_data_ = + ProxyConnectionRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ProxyConnectionRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ProxyConnectionRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ProxyConnectionRequest_class_data_.tc_table); + return ProxyConnectionRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> +ProxyConnectionRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_._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 + ProxyConnectionRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ProxyConnectionRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bytes userId = 2; + {::_pbi::TcParser::FastBS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_.userid_)}}, + // .ProxyDirection direction = 1; + {::_pbi::TcParser::FastV32S1, + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_.direction_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .ProxyDirection direction = 1; + {PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_.direction_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // bytes userId = 2; + {PROTOBUF_FIELD_OFFSET(ProxyConnectionRequest, _impl_.userid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + }}, +}; +void ProxyConnectionRequest::InternalSwap(ProxyConnectionRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ProxyConnectionRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[13]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ProxyConnectionResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ProxyConnectionResponse, _impl_._has_bits_); }; -ProxyConnectionResponse::ProxyConnectionResponse(::google::protobuf::Arena* arena) +ProxyConnectionResponse::ProxyConnectionResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ProxyConnectionResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ProxyConnectionResponse) } ProxyConnectionResponse::ProxyConnectionResponse( - ::google::protobuf::Arena* arena, const ProxyConnectionResponse& from) - : ProxyConnectionResponse(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ProxyConnectionResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ProxyConnectionResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE ProxyConnectionResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE ProxyConnectionResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void ProxyConnectionResponse::SharedCtor(::_pb::Arena* arena) { +inline void ProxyConnectionResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.accepted_ = {}; } ProxyConnectionResponse::~ProxyConnectionResponse() { // @@protoc_insertion_point(destructor:ProxyConnectionResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ProxyConnectionResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void ProxyConnectionResponse::SharedDtor(MessageLite& self) { + ProxyConnectionResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ProxyConnectionResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ProxyConnectionResponse(arena); +} +constexpr auto ProxyConnectionResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ProxyConnectionResponse), + alignof(ProxyConnectionResponse)); +} +constexpr auto ProxyConnectionResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ProxyConnectionResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ProxyConnectionResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ProxyConnectionResponse::SharedDtor, + static_cast(&ProxyConnectionResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ProxyConnectionResponse, _impl_._cached_size_), + false, + }, + &ProxyConnectionResponse::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* ProxyConnectionResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void ProxyConnectionResponse::InternalSwap(ProxyConnectionResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ProxyConnectionResponse_class_data_ = + ProxyConnectionResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ProxyConnectionResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ProxyConnectionResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ProxyConnectionResponse_class_data_.tc_table); + return ProxyConnectionResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +ProxyConnectionResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ProxyConnectionResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ProxyConnectionResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ProxyConnectionResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool accepted = 1; + {::_pbi::TcParser::FastV8S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(ProxyConnectionResponse, _impl_.accepted_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool accepted = 1; + {PROTOBUF_FIELD_OFFSET(ProxyConnectionResponse, _impl_.accepted_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; +void ProxyConnectionResponse::InternalSwap(ProxyConnectionResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ProxyConnectionResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[14]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -2151,14 +3745,22 @@ class TemporaryConnectionRequest::_Internal { public: }; -TemporaryConnectionRequest::TemporaryConnectionRequest(::google::protobuf::Arena* arena) +TemporaryConnectionRequest::TemporaryConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, TemporaryConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:TemporaryConnectionRequest) } TemporaryConnectionRequest::TemporaryConnectionRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TemporaryConnectionRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, TemporaryConnectionRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE TemporaryConnectionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -2167,58 +3769,216 @@ TemporaryConnectionRequest::TemporaryConnectionRequest( // @@protoc_insertion_point(copy_constructor:TemporaryConnectionRequest) } +inline void* PROTOBUF_NONNULL TemporaryConnectionRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) TemporaryConnectionRequest(arena); +} +constexpr auto TemporaryConnectionRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TemporaryConnectionRequest), + alignof(TemporaryConnectionRequest)); +} +constexpr auto TemporaryConnectionRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_TemporaryConnectionRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &TemporaryConnectionRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &TemporaryConnectionRequest::SharedDtor, + static_cast(&TemporaryConnectionRequest::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(TemporaryConnectionRequest, _impl_._cached_size_), + false, + }, + &TemporaryConnectionRequest::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull TemporaryConnectionRequest_class_data_ = + TemporaryConnectionRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +TemporaryConnectionRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&TemporaryConnectionRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(TemporaryConnectionRequest_class_data_.tc_table); + return TemporaryConnectionRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +TemporaryConnectionRequest::_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 + TemporaryConnectionRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::TemporaryConnectionRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata TemporaryConnectionRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[15]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class TemporaryConnectionResponse::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(TemporaryConnectionResponse, _impl_._has_bits_); }; -TemporaryConnectionResponse::TemporaryConnectionResponse(::google::protobuf::Arena* arena) +TemporaryConnectionResponse::TemporaryConnectionResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, TemporaryConnectionResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:TemporaryConnectionResponse) } TemporaryConnectionResponse::TemporaryConnectionResponse( - ::google::protobuf::Arena* arena, const TemporaryConnectionResponse& from) - : TemporaryConnectionResponse(arena) { - MergeFrom(from); + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TemporaryConnectionResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, TemporaryConnectionResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); } -inline PROTOBUF_NDEBUG_INLINE TemporaryConnectionResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE TemporaryConnectionResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void TemporaryConnectionResponse::SharedCtor(::_pb::Arena* arena) { +inline void TemporaryConnectionResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.accepted_ = {}; } TemporaryConnectionResponse::~TemporaryConnectionResponse() { // @@protoc_insertion_point(destructor:TemporaryConnectionResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void TemporaryConnectionResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void TemporaryConnectionResponse::SharedDtor(MessageLite& self) { + TemporaryConnectionResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL TemporaryConnectionResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) TemporaryConnectionResponse(arena); +} +constexpr auto TemporaryConnectionResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TemporaryConnectionResponse), + alignof(TemporaryConnectionResponse)); +} +constexpr auto TemporaryConnectionResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_TemporaryConnectionResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &TemporaryConnectionResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &TemporaryConnectionResponse::SharedDtor, + static_cast(&TemporaryConnectionResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(TemporaryConnectionResponse, _impl_._cached_size_), + false, + }, + &TemporaryConnectionResponse::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* TemporaryConnectionResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void TemporaryConnectionResponse::InternalSwap(TemporaryConnectionResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull TemporaryConnectionResponse_class_data_ = + TemporaryConnectionResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +TemporaryConnectionResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&TemporaryConnectionResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(TemporaryConnectionResponse_class_data_.tc_table); + return TemporaryConnectionResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> +TemporaryConnectionResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(TemporaryConnectionResponse, _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 + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + TemporaryConnectionResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::TemporaryConnectionResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool accepted = 1; + {::_pbi::TcParser::FastV8S1, + {8, 0, 0, + PROTOBUF_FIELD_OFFSET(TemporaryConnectionResponse, _impl_.accepted_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool accepted = 1; + {PROTOBUF_FIELD_OFFSET(TemporaryConnectionResponse, _impl_.accepted_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; +void TemporaryConnectionResponse::InternalSwap(TemporaryConnectionResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata TemporaryConnectionResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[16]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -2226,14 +3986,22 @@ class CloseTemporaryConnection::_Internal { public: }; -CloseTemporaryConnection::CloseTemporaryConnection(::google::protobuf::Arena* arena) +CloseTemporaryConnection::CloseTemporaryConnection(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, CloseTemporaryConnection_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:CloseTemporaryConnection) } CloseTemporaryConnection::CloseTemporaryConnection( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CloseTemporaryConnection& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, CloseTemporaryConnection_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE CloseTemporaryConnection* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -2242,154 +4010,470 @@ CloseTemporaryConnection::CloseTemporaryConnection( // @@protoc_insertion_point(copy_constructor:CloseTemporaryConnection) } +inline void* PROTOBUF_NONNULL CloseTemporaryConnection::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) CloseTemporaryConnection(arena); +} +constexpr auto CloseTemporaryConnection::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CloseTemporaryConnection), + alignof(CloseTemporaryConnection)); +} +constexpr auto CloseTemporaryConnection::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_CloseTemporaryConnection_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CloseTemporaryConnection::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CloseTemporaryConnection::SharedDtor, + static_cast(&CloseTemporaryConnection::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CloseTemporaryConnection, _impl_._cached_size_), + false, + }, + &CloseTemporaryConnection::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull CloseTemporaryConnection_class_data_ = + CloseTemporaryConnection::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +CloseTemporaryConnection::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&CloseTemporaryConnection_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(CloseTemporaryConnection_class_data_.tc_table); + return CloseTemporaryConnection_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +CloseTemporaryConnection::_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 + CloseTemporaryConnection_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::CloseTemporaryConnection>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata CloseTemporaryConnection::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[17]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StreamPartitionInfo::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_._has_bits_); }; void StreamPartitionInfo::clear_controllayerneighbors() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.controllayerneighbors_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } void StreamPartitionInfo::clear_contentdeliverylayerneighbors() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.contentdeliverylayerneighbors_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -StreamPartitionInfo::StreamPartitionInfo(::google::protobuf::Arena* arena) +StreamPartitionInfo::StreamPartitionInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamPartitionInfo_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:StreamPartitionInfo) } -inline PROTOBUF_NDEBUG_INLINE StreamPartitionInfo::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : controllayerneighbors_{visibility, arena, from.controllayerneighbors_}, +PROTOBUF_NDEBUG_INLINE StreamPartitionInfo::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::StreamPartitionInfo& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + controllayerneighbors_{visibility, arena, from.controllayerneighbors_}, contentdeliverylayerneighbors_{visibility, arena, from.contentdeliverylayerneighbors_}, - id_(arena, from.id_), - _cached_size_{0} {} + id_(arena, from.id_) {} StreamPartitionInfo::StreamPartitionInfo( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamPartitionInfo& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, StreamPartitionInfo_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE StreamPartitionInfo* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:StreamPartitionInfo) } -inline PROTOBUF_NDEBUG_INLINE StreamPartitionInfo::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : controllayerneighbors_{visibility, arena}, +PROTOBUF_NDEBUG_INLINE StreamPartitionInfo::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + controllayerneighbors_{visibility, arena}, contentdeliverylayerneighbors_{visibility, arena}, - id_(arena), - _cached_size_{0} {} + id_(arena) {} -inline void StreamPartitionInfo::SharedCtor(::_pb::Arena* arena) { +inline void StreamPartitionInfo::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } StreamPartitionInfo::~StreamPartitionInfo() { // @@protoc_insertion_point(destructor:StreamPartitionInfo) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void StreamPartitionInfo::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.id_.Destroy(); - _impl_.~Impl_(); +inline void StreamPartitionInfo::SharedDtor(MessageLite& self) { + StreamPartitionInfo& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.id_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL StreamPartitionInfo::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) StreamPartitionInfo(arena); +} +constexpr auto StreamPartitionInfo::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.controllayerneighbors_) + + decltype(StreamPartitionInfo::_impl_.controllayerneighbors_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.contentdeliverylayerneighbors_) + + decltype(StreamPartitionInfo::_impl_.contentdeliverylayerneighbors_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(StreamPartitionInfo), alignof(StreamPartitionInfo), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&StreamPartitionInfo::PlacementNew_, + sizeof(StreamPartitionInfo), + alignof(StreamPartitionInfo)); + } } - -::_pbi::CachedSize* StreamPartitionInfo::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto StreamPartitionInfo::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_StreamPartitionInfo_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StreamPartitionInfo::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StreamPartitionInfo::SharedDtor, + static_cast(&StreamPartitionInfo::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_._cached_size_), + false, + }, + &StreamPartitionInfo::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -void StreamPartitionInfo::InternalSwap(StreamPartitionInfo* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull StreamPartitionInfo_class_data_ = + StreamPartitionInfo::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +StreamPartitionInfo::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&StreamPartitionInfo_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(StreamPartitionInfo_class_data_.tc_table); + return StreamPartitionInfo_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 30, 2> +StreamPartitionInfo::_table_ = { + { + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + StreamPartitionInfo_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::StreamPartitionInfo>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string id = 1; + {::_pbi::TcParser::FastUS1, + {10, 2, 0, + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.id_)}}, + // repeated .dht.PeerDescriptor controlLayerNeighbors = 2; + {::_pbi::TcParser::FastMtR1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.controllayerneighbors_)}}, + // repeated .dht.PeerDescriptor contentDeliveryLayerNeighbors = 3; + {::_pbi::TcParser::FastMtR1, + {26, 1, 1, + PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.contentdeliverylayerneighbors_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string id = 1; + {PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.id_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // repeated .dht.PeerDescriptor controlLayerNeighbors = 2; + {PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.controllayerneighbors_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor contentDeliveryLayerNeighbors = 3; + {PROTOBUF_FIELD_OFFSET(StreamPartitionInfo, _impl_.contentdeliverylayerneighbors_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + "\23\2\0\0\0\0\0\0" + "StreamPartitionInfo" + "id" + }}, +}; +void StreamPartitionInfo::InternalSwap(StreamPartitionInfo* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata StreamPartitionInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[18]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ControlLayerInfo::_Internal { public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_._has_bits_); }; void ControlLayerInfo::clear_neighbors() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.neighbors_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } void ControlLayerInfo::clear_connections() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.connections_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000002U); } -ControlLayerInfo::ControlLayerInfo(::google::protobuf::Arena* arena) +ControlLayerInfo::ControlLayerInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ControlLayerInfo_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:ControlLayerInfo) } -inline PROTOBUF_NDEBUG_INLINE ControlLayerInfo::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) - : neighbors_{visibility, arena, from.neighbors_}, - connections_{visibility, arena, from.connections_}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ControlLayerInfo::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::ControlLayerInfo& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + neighbors_{visibility, arena, from.neighbors_}, + connections_{visibility, arena, from.connections_} {} ControlLayerInfo::ControlLayerInfo( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ControlLayerInfo& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ControlLayerInfo_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE ControlLayerInfo* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:ControlLayerInfo) } -inline PROTOBUF_NDEBUG_INLINE ControlLayerInfo::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : neighbors_{visibility, arena}, - connections_{visibility, arena}, - _cached_size_{0} {} +PROTOBUF_NDEBUG_INLINE ControlLayerInfo::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + neighbors_{visibility, arena}, + connections_{visibility, arena} {} -inline void ControlLayerInfo::SharedCtor(::_pb::Arena* arena) { +inline void ControlLayerInfo::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ControlLayerInfo::~ControlLayerInfo() { // @@protoc_insertion_point(destructor:ControlLayerInfo) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void ControlLayerInfo::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.~Impl_(); +inline void ControlLayerInfo::SharedDtor(MessageLite& self) { + ControlLayerInfo& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ControlLayerInfo::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ControlLayerInfo(arena); +} +constexpr auto ControlLayerInfo::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_.neighbors_) + + decltype(ControlLayerInfo::_impl_.neighbors_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_.connections_) + + decltype(ControlLayerInfo::_impl_.connections_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(ControlLayerInfo), alignof(ControlLayerInfo), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&ControlLayerInfo::PlacementNew_, + sizeof(ControlLayerInfo), + alignof(ControlLayerInfo)); + } } - -::_pbi::CachedSize* ControlLayerInfo::AccessCachedSize() const { - return &_impl_._cached_size_; +constexpr auto ControlLayerInfo::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ControlLayerInfo_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ControlLayerInfo::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ControlLayerInfo::SharedDtor, + static_cast(&ControlLayerInfo::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_._cached_size_), + false, + }, + &ControlLayerInfo::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -void ControlLayerInfo::InternalSwap(ControlLayerInfo* PROTOBUF_RESTRICT other) { - using std::swap; + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ControlLayerInfo_class_data_ = + ControlLayerInfo::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ControlLayerInfo::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ControlLayerInfo_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ControlLayerInfo_class_data_.tc_table); + return ControlLayerInfo_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +ControlLayerInfo::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_._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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + ControlLayerInfo_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::ControlLayerInfo>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .dht.PeerDescriptor connections = 2; + {::_pbi::TcParser::FastMtR1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_.connections_)}}, + // repeated .dht.PeerDescriptor neighbors = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_.neighbors_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .dht.PeerDescriptor neighbors = 1; + {PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_.neighbors_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dht.PeerDescriptor connections = 2; + {PROTOBUF_FIELD_OFFSET(ControlLayerInfo, _impl_.connections_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + }}, + {{ + }}, +}; +void ControlLayerInfo::InternalSwap(ControlLayerInfo* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata ControlLayerInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[19]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -2397,14 +4481,22 @@ class NodeInfoRequest::_Internal { public: }; -NodeInfoRequest::NodeInfoRequest(::google::protobuf::Arena* arena) +NodeInfoRequest::NodeInfoRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, NodeInfoRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE // @@protoc_insertion_point(arena_constructor:NodeInfoRequest) } NodeInfoRequest::NodeInfoRequest( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeInfoRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, NodeInfoRequest_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE NodeInfoRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -2413,82 +4505,147 @@ NodeInfoRequest::NodeInfoRequest( // @@protoc_insertion_point(copy_constructor:NodeInfoRequest) } +inline void* PROTOBUF_NONNULL NodeInfoRequest::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) NodeInfoRequest(arena); +} +constexpr auto NodeInfoRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(NodeInfoRequest), + alignof(NodeInfoRequest)); +} +constexpr auto NodeInfoRequest::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_NodeInfoRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &NodeInfoRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &NodeInfoRequest::SharedDtor, + static_cast(&NodeInfoRequest::ClearImpl), + ::google::protobuf::internal::ZeroFieldsBase::ByteSizeLongImpl, ::google::protobuf::internal::ZeroFieldsBase::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(NodeInfoRequest, _impl_._cached_size_), + false, + }, + &NodeInfoRequest::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull NodeInfoRequest_class_data_ = + NodeInfoRequest::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +NodeInfoRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&NodeInfoRequest_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(NodeInfoRequest_class_data_.tc_table); + return NodeInfoRequest_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> +NodeInfoRequest::_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 + NodeInfoRequest_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::NodeInfoRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, // no field_entries, or aux_entries + {{ + }}, +}; ::google::protobuf::Metadata NodeInfoRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[20]); + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NodeInfoResponse::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_._has_bits_); - static const ::dht::PeerDescriptor& peerdescriptor(const NodeInfoResponse* msg); - static void set_has_peerdescriptor(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::ControlLayerInfo& controllayer(const NodeInfoResponse* msg); - static void set_has_controllayer(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } + 8 * PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_._has_bits_); }; -const ::dht::PeerDescriptor& NodeInfoResponse::_Internal::peerdescriptor(const NodeInfoResponse* msg) { - return *msg->_impl_.peerdescriptor_; -} -const ::ControlLayerInfo& NodeInfoResponse::_Internal::controllayer(const NodeInfoResponse* msg) { - return *msg->_impl_.controllayer_; -} void NodeInfoResponse::clear_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peerdescriptor_ != nullptr) _impl_.peerdescriptor_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -NodeInfoResponse::NodeInfoResponse(::google::protobuf::Arena* arena) +NodeInfoResponse::NodeInfoResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, NodeInfoResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:NodeInfoResponse) } -inline PROTOBUF_NDEBUG_INLINE NodeInfoResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE NodeInfoResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::NodeInfoResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, streampartitions_{visibility, arena, from.streampartitions_}, version_(arena, from.version_) {} NodeInfoResponse::NodeInfoResponse( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeInfoResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, NodeInfoResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE NodeInfoResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.peerdescriptor_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::dht::PeerDescriptor>(arena, *from._impl_.peerdescriptor_) + _impl_.peerdescriptor_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.peerdescriptor_) : nullptr; - _impl_.controllayer_ = (cached_has_bits & 0x00000002u) - ? CreateMaybeMessage<::ControlLayerInfo>(arena, *from._impl_.controllayer_) + _impl_.controllayer_ = (CheckHasBit(cached_has_bits, 0x00000008U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.controllayer_) : nullptr; // @@protoc_insertion_point(copy_constructor:NodeInfoResponse) } -inline PROTOBUF_NDEBUG_INLINE NodeInfoResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE NodeInfoResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, streampartitions_{visibility, arena}, version_(arena) {} -inline void NodeInfoResponse::SharedCtor(::_pb::Arena* arena) { +inline void NodeInfoResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, peerdescriptor_), 0, offsetof(Impl_, controllayer_) - @@ -2497,28 +4654,141 @@ inline void NodeInfoResponse::SharedCtor(::_pb::Arena* arena) { } NodeInfoResponse::~NodeInfoResponse() { // @@protoc_insertion_point(destructor:NodeInfoResponse) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); +} +inline void NodeInfoResponse::SharedDtor(MessageLite& self) { + NodeInfoResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.version_.Destroy(); + delete this_._impl_.peerdescriptor_; + delete this_._impl_.controllayer_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL NodeInfoResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) NodeInfoResponse(arena); +} +constexpr auto NodeInfoResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.streampartitions_) + + decltype(NodeInfoResponse::_impl_.streampartitions_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(NodeInfoResponse), alignof(NodeInfoResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&NodeInfoResponse::PlacementNew_, + sizeof(NodeInfoResponse), + alignof(NodeInfoResponse)); + } } -inline void NodeInfoResponse::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.version_.Destroy(); - delete _impl_.peerdescriptor_; - delete _impl_.controllayer_; - _impl_.~Impl_(); +constexpr auto NodeInfoResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_NodeInfoResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &NodeInfoResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &NodeInfoResponse::SharedDtor, + static_cast(&NodeInfoResponse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_._cached_size_), + false, + }, + &NodeInfoResponse::kDescriptorMethods, + &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto, + nullptr, // tracker + }; } -::_pbi::CachedSize* NodeInfoResponse::AccessCachedSize() const { - return &_impl_._cached_size_; -} -void NodeInfoResponse::InternalSwap(NodeInfoResponse* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull NodeInfoResponse_class_data_ = + NodeInfoResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +NodeInfoResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&NodeInfoResponse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(NodeInfoResponse_class_data_.tc_table); + return NodeInfoResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 3, 32, 2> +NodeInfoResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_._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 + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + NodeInfoResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::NodeInfoResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string version = 4; + {::_pbi::TcParser::FastUS1, + {34, 1, 0, + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.version_)}}, + // .dht.PeerDescriptor peerDescriptor = 1; + {::_pbi::TcParser::FastMtS1, + {10, 2, 0, + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.peerdescriptor_)}}, + // repeated .StreamPartitionInfo streamPartitions = 2; + {::_pbi::TcParser::FastMtR1, + {18, 0, 1, + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.streampartitions_)}}, + // optional .ControlLayerInfo controlLayer = 3; + {::_pbi::TcParser::FastMtS1, + {26, 3, 2, + PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.controllayer_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dht.PeerDescriptor peerDescriptor = 1; + {PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.peerdescriptor_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .StreamPartitionInfo streamPartitions = 2; + {PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.streampartitions_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .ControlLayerInfo controlLayer = 3; + {PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.controllayer_), _Internal::kHasBitsOffset + 3, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string version = 4; + {PROTOBUF_FIELD_OFFSET(NodeInfoResponse, _impl_.version_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::dht::PeerDescriptor>()}, + {::_pbi::TcParser::GetTable<::StreamPartitionInfo>()}, + {::_pbi::TcParser::GetTable<::ControlLayerInfo>()}, + }}, + {{ + "\20\0\0\0\7\0\0\0" + "NodeInfoResponse" + "version" + }}, +}; +void NodeInfoResponse::InternalSwap(NodeInfoResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata NodeInfoResponse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_getter, &descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_once, - file_level_metadata_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto[21]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) namespace google { @@ -2526,4 +4796,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.h b/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.h index 6f12a3a2..54a0b373 100644 --- a/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.h +++ b/packages/streamr-trackerless-network/src/proto/packages/network/protos/NetworkRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/network/protos/NetworkRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_2epb_2eh +#ifndef packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_2epb_2eh +#define packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -31,6 +25,7 @@ #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/generated_enum_reflection.h" @@ -48,7 +43,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -57,76 +53,119 @@ class AnyMetadata; struct TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; +} // extern "C" +enum ContentType : int; +extern const uint32_t ContentType_internal_data_[]; +enum EncryptionType : int; +extern const uint32_t EncryptionType_internal_data_[]; +enum ProxyDirection : int; +extern const uint32_t ProxyDirection_internal_data_[]; +enum SignatureType : int; +extern const uint32_t SignatureType_internal_data_[]; class CloseTemporaryConnection; struct CloseTemporaryConnectionDefaultTypeInternal; extern CloseTemporaryConnectionDefaultTypeInternal _CloseTemporaryConnection_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull CloseTemporaryConnection_class_data_; class ContentMessage; struct ContentMessageDefaultTypeInternal; extern ContentMessageDefaultTypeInternal _ContentMessage_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ContentMessage_class_data_; class ControlLayerInfo; struct ControlLayerInfoDefaultTypeInternal; extern ControlLayerInfoDefaultTypeInternal _ControlLayerInfo_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ControlLayerInfo_class_data_; class GroupKey; struct GroupKeyDefaultTypeInternal; extern GroupKeyDefaultTypeInternal _GroupKey_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull GroupKey_class_data_; class GroupKeyRequest; struct GroupKeyRequestDefaultTypeInternal; extern GroupKeyRequestDefaultTypeInternal _GroupKeyRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull GroupKeyRequest_class_data_; class GroupKeyResponse; struct GroupKeyResponseDefaultTypeInternal; extern GroupKeyResponseDefaultTypeInternal _GroupKeyResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull GroupKeyResponse_class_data_; class InterleaveRequest; struct InterleaveRequestDefaultTypeInternal; extern InterleaveRequestDefaultTypeInternal _InterleaveRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull InterleaveRequest_class_data_; class InterleaveResponse; struct InterleaveResponseDefaultTypeInternal; extern InterleaveResponseDefaultTypeInternal _InterleaveResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull InterleaveResponse_class_data_; class LeaveStreamPartNotice; struct LeaveStreamPartNoticeDefaultTypeInternal; extern LeaveStreamPartNoticeDefaultTypeInternal _LeaveStreamPartNotice_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull LeaveStreamPartNotice_class_data_; class MessageID; struct MessageIDDefaultTypeInternal; extern MessageIDDefaultTypeInternal _MessageID_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull MessageID_class_data_; class MessageRef; struct MessageRefDefaultTypeInternal; extern MessageRefDefaultTypeInternal _MessageRef_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull MessageRef_class_data_; class NeighborUpdate; struct NeighborUpdateDefaultTypeInternal; extern NeighborUpdateDefaultTypeInternal _NeighborUpdate_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull NeighborUpdate_class_data_; class NodeInfoRequest; struct NodeInfoRequestDefaultTypeInternal; extern NodeInfoRequestDefaultTypeInternal _NodeInfoRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull NodeInfoRequest_class_data_; class NodeInfoResponse; struct NodeInfoResponseDefaultTypeInternal; extern NodeInfoResponseDefaultTypeInternal _NodeInfoResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull NodeInfoResponse_class_data_; class ProxyConnectionRequest; struct ProxyConnectionRequestDefaultTypeInternal; extern ProxyConnectionRequestDefaultTypeInternal _ProxyConnectionRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ProxyConnectionRequest_class_data_; class ProxyConnectionResponse; struct ProxyConnectionResponseDefaultTypeInternal; extern ProxyConnectionResponseDefaultTypeInternal _ProxyConnectionResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ProxyConnectionResponse_class_data_; class StreamMessage; struct StreamMessageDefaultTypeInternal; extern StreamMessageDefaultTypeInternal _StreamMessage_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StreamMessage_class_data_; class StreamPartHandshakeRequest; struct StreamPartHandshakeRequestDefaultTypeInternal; extern StreamPartHandshakeRequestDefaultTypeInternal _StreamPartHandshakeRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StreamPartHandshakeRequest_class_data_; class StreamPartHandshakeResponse; struct StreamPartHandshakeResponseDefaultTypeInternal; extern StreamPartHandshakeResponseDefaultTypeInternal _StreamPartHandshakeResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StreamPartHandshakeResponse_class_data_; class StreamPartitionInfo; struct StreamPartitionInfoDefaultTypeInternal; extern StreamPartitionInfoDefaultTypeInternal _StreamPartitionInfo_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull StreamPartitionInfo_class_data_; class TemporaryConnectionRequest; struct TemporaryConnectionRequestDefaultTypeInternal; extern TemporaryConnectionRequestDefaultTypeInternal _TemporaryConnectionRequest_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull TemporaryConnectionRequest_class_data_; class TemporaryConnectionResponse; struct TemporaryConnectionResponseDefaultTypeInternal; extern TemporaryConnectionResponseDefaultTypeInternal _TemporaryConnectionResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull TemporaryConnectionResponse_class_data_; namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::ContentType_internal_data_> + internal::EnumTraitsImpl::value<::ContentType>; +template <> +internal::EnumTraitsT<::EncryptionType_internal_data_> + internal::EnumTraitsImpl::value<::EncryptionType>; +template <> +internal::EnumTraitsT<::ProxyDirection_internal_data_> + internal::EnumTraitsImpl::value<::ProxyDirection>; +template <> +internal::EnumTraitsT<::SignatureType_internal_data_> + internal::EnumTraitsImpl::value<::SignatureType>; } // namespace protobuf } // namespace google @@ -134,134 +173,146 @@ enum ContentType : int { JSON = 0, BINARY = 1, ContentType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), ContentType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool ContentType_IsValid(int value); extern const uint32_t ContentType_internal_data_[]; -constexpr ContentType ContentType_MIN = static_cast(0); -constexpr ContentType ContentType_MAX = static_cast(1); -constexpr int ContentType_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -ContentType_descriptor(); +inline constexpr ContentType ContentType_MIN = + static_cast(0); +inline constexpr ContentType ContentType_MAX = + static_cast(1); +inline bool ContentType_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int ContentType_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ContentType_descriptor(); template -const std::string& ContentType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& ContentType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to ContentType_Name()."); return ContentType_Name(static_cast(value)); } template <> -inline const std::string& ContentType_Name(ContentType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& ContentType_Name(ContentType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool ContentType_Parse(absl::string_view name, ContentType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - ContentType_descriptor(), name, value); +inline bool ContentType_Parse( + ::absl::string_view name, ContentType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(ContentType_descriptor(), name, + value); } enum EncryptionType : int { NONE = 0, AES = 1, EncryptionType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), EncryptionType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool EncryptionType_IsValid(int value); extern const uint32_t EncryptionType_internal_data_[]; -constexpr EncryptionType EncryptionType_MIN = static_cast(0); -constexpr EncryptionType EncryptionType_MAX = static_cast(1); -constexpr int EncryptionType_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -EncryptionType_descriptor(); +inline constexpr EncryptionType EncryptionType_MIN = + static_cast(0); +inline constexpr EncryptionType EncryptionType_MAX = + static_cast(1); +inline bool EncryptionType_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int EncryptionType_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL EncryptionType_descriptor(); template -const std::string& EncryptionType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& EncryptionType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to EncryptionType_Name()."); return EncryptionType_Name(static_cast(value)); } template <> -inline const std::string& EncryptionType_Name(EncryptionType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& EncryptionType_Name(EncryptionType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool EncryptionType_Parse(absl::string_view name, EncryptionType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - EncryptionType_descriptor(), name, value); +inline bool EncryptionType_Parse( + ::absl::string_view name, EncryptionType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(EncryptionType_descriptor(), name, + value); } enum SignatureType : int { LEGACY_SECP256K1 = 0, SECP256K1 = 1, ERC_1271 = 2, SignatureType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), SignatureType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool SignatureType_IsValid(int value); extern const uint32_t SignatureType_internal_data_[]; -constexpr SignatureType SignatureType_MIN = static_cast(0); -constexpr SignatureType SignatureType_MAX = static_cast(2); -constexpr int SignatureType_ARRAYSIZE = 2 + 1; -const ::google::protobuf::EnumDescriptor* -SignatureType_descriptor(); +inline constexpr SignatureType SignatureType_MIN = + static_cast(0); +inline constexpr SignatureType SignatureType_MAX = + static_cast(2); +inline bool SignatureType_IsValid(int value) { + return 0 <= value && value <= 2; +} +inline constexpr int SignatureType_ARRAYSIZE = 2 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SignatureType_descriptor(); template -const std::string& SignatureType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& SignatureType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to SignatureType_Name()."); return SignatureType_Name(static_cast(value)); } template <> -inline const std::string& SignatureType_Name(SignatureType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& SignatureType_Name(SignatureType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool SignatureType_Parse(absl::string_view name, SignatureType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - SignatureType_descriptor(), name, value); +inline bool SignatureType_Parse( + ::absl::string_view name, SignatureType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(SignatureType_descriptor(), name, + value); } enum ProxyDirection : int { PUBLISH = 0, SUBSCRIBE = 1, ProxyDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), ProxyDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool ProxyDirection_IsValid(int value); extern const uint32_t ProxyDirection_internal_data_[]; -constexpr ProxyDirection ProxyDirection_MIN = static_cast(0); -constexpr ProxyDirection ProxyDirection_MAX = static_cast(1); -constexpr int ProxyDirection_ARRAYSIZE = 1 + 1; -const ::google::protobuf::EnumDescriptor* -ProxyDirection_descriptor(); +inline constexpr ProxyDirection ProxyDirection_MIN = + static_cast(0); +inline constexpr ProxyDirection ProxyDirection_MAX = + static_cast(1); +inline bool ProxyDirection_IsValid(int value) { + return 0 <= value && value <= 1; +} +inline constexpr int ProxyDirection_ARRAYSIZE = 1 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ProxyDirection_descriptor(); template -const std::string& ProxyDirection_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& ProxyDirection_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to ProxyDirection_Name()."); return ProxyDirection_Name(static_cast(value)); } template <> -inline const std::string& ProxyDirection_Name(ProxyDirection value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& ProxyDirection_Name(ProxyDirection value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool ProxyDirection_Parse(absl::string_view name, ProxyDirection* value) { - return ::google::protobuf::internal::ParseNamedEnum( - ProxyDirection_descriptor(), name, value); +inline bool ProxyDirection_Parse( + ::absl::string_view name, ProxyDirection* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(ProxyDirection_descriptor(), name, + value); } // =================================================================== @@ -269,32 +320,32 @@ inline bool ProxyDirection_Parse(absl::string_view name, ProxyDirection* value) // ------------------------------------------------------------------- -class TemporaryConnectionResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:TemporaryConnectionResponse) */ { +class TemporaryConnectionResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:TemporaryConnectionResponse) */ { public: inline TemporaryConnectionResponse() : TemporaryConnectionResponse(nullptr) {} - ~TemporaryConnectionResponse() override; - template - explicit PROTOBUF_CONSTEXPR TemporaryConnectionResponse(::google::protobuf::internal::ConstantInitialized); + ~TemporaryConnectionResponse() PROTOBUF_FINAL; - inline TemporaryConnectionResponse(const TemporaryConnectionResponse& from) - : TemporaryConnectionResponse(nullptr, from) {} - TemporaryConnectionResponse(TemporaryConnectionResponse&& from) noexcept - : TemporaryConnectionResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(TemporaryConnectionResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(TemporaryConnectionResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR TemporaryConnectionResponse(::google::protobuf::internal::ConstantInitialized); + inline TemporaryConnectionResponse(const TemporaryConnectionResponse& from) : TemporaryConnectionResponse(nullptr, from) {} + inline TemporaryConnectionResponse(TemporaryConnectionResponse&& from) noexcept + : TemporaryConnectionResponse(nullptr, ::std::move(from)) {} inline TemporaryConnectionResponse& operator=(const TemporaryConnectionResponse& from) { CopyFrom(from); return *this; } inline TemporaryConnectionResponse& operator=(TemporaryConnectionResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -306,47 +357,35 @@ class TemporaryConnectionResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const TemporaryConnectionResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_TemporaryConnectionResponse_default_instance_); } - static inline const TemporaryConnectionResponse* internal_default_instance() { - return reinterpret_cast( - &_TemporaryConnectionResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(TemporaryConnectionResponse& a, TemporaryConnectionResponse& b) { - a.Swap(&b); - } - inline void Swap(TemporaryConnectionResponse* other) { + static constexpr int kIndexInFileMessages = 16; + friend void swap(TemporaryConnectionResponse& a, TemporaryConnectionResponse& b) { a.Swap(&b); } + inline void Swap(TemporaryConnectionResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(TemporaryConnectionResponse* other) { + void UnsafeArenaSwap(TemporaryConnectionResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -354,33 +393,40 @@ class TemporaryConnectionResponse final : // implements Message ---------------------------------------------- - TemporaryConnectionResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + TemporaryConnectionResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(TemporaryConnectionResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "TemporaryConnectionResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(TemporaryConnectionResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "TemporaryConnectionResponse"; } + + explicit TemporaryConnectionResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + TemporaryConnectionResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TemporaryConnectionResponse& from); + TemporaryConnectionResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TemporaryConnectionResponse&& from) noexcept + : TemporaryConnectionResponse(arena) { + *this = ::std::move(from); } - protected: - explicit TemporaryConnectionResponse(::google::protobuf::Arena* arena); - TemporaryConnectionResponse(::google::protobuf::Arena* arena, const TemporaryConnectionResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kAcceptedFieldNumber = 1, }; @@ -397,6 +443,11 @@ class TemporaryConnectionResponse final : // @@protoc_insertion_point(class_scope:TemporaryConnectionResponse) 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; @@ -405,46 +456,51 @@ class TemporaryConnectionResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const TemporaryConnectionResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; bool accepted_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull TemporaryConnectionResponse_class_data_; +// ------------------------------------------------------------------- -class TemporaryConnectionRequest final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:TemporaryConnectionRequest) */ { +class TemporaryConnectionRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:TemporaryConnectionRequest) */ { public: inline TemporaryConnectionRequest() : TemporaryConnectionRequest(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR TemporaryConnectionRequest(::google::protobuf::internal::ConstantInitialized); - inline TemporaryConnectionRequest(const TemporaryConnectionRequest& from) - : TemporaryConnectionRequest(nullptr, from) {} - TemporaryConnectionRequest(TemporaryConnectionRequest&& from) noexcept - : TemporaryConnectionRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(TemporaryConnectionRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(TemporaryConnectionRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR TemporaryConnectionRequest(::google::protobuf::internal::ConstantInitialized); + inline TemporaryConnectionRequest(const TemporaryConnectionRequest& from) : TemporaryConnectionRequest(nullptr, from) {} + inline TemporaryConnectionRequest(TemporaryConnectionRequest&& from) noexcept + : TemporaryConnectionRequest(nullptr, ::std::move(from)) {} inline TemporaryConnectionRequest& operator=(const TemporaryConnectionRequest& from) { CopyFrom(from); return *this; } inline TemporaryConnectionRequest& operator=(TemporaryConnectionRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -456,47 +512,35 @@ class TemporaryConnectionRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const TemporaryConnectionRequest& default_instance() { - return *internal_default_instance(); - } - static inline const TemporaryConnectionRequest* internal_default_instance() { - return reinterpret_cast( - &_TemporaryConnectionRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(TemporaryConnectionRequest& a, TemporaryConnectionRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_TemporaryConnectionRequest_default_instance_); } - inline void Swap(TemporaryConnectionRequest* other) { + static constexpr int kIndexInFileMessages = 15; + friend void swap(TemporaryConnectionRequest& a, TemporaryConnectionRequest& b) { a.Swap(&b); } + inline void Swap(TemporaryConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(TemporaryConnectionRequest* other) { + void UnsafeArenaSwap(TemporaryConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -504,29 +548,42 @@ class TemporaryConnectionRequest final : // implements Message ---------------------------------------------- - TemporaryConnectionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + TemporaryConnectionRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "TemporaryConnectionRequest"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "TemporaryConnectionRequest"; } + + explicit TemporaryConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + TemporaryConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TemporaryConnectionRequest& from); + TemporaryConnectionRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TemporaryConnectionRequest&& from) noexcept + : TemporaryConnectionRequest(arena) { + *this = ::std::move(from); } - protected: - explicit TemporaryConnectionRequest(::google::protobuf::Arena* arena); - TemporaryConnectionRequest(::google::protobuf::Arena* arena, const TemporaryConnectionRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:TemporaryConnectionRequest) 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; @@ -534,45 +591,38 @@ class TemporaryConnectionRequest final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull TemporaryConnectionRequest_class_data_; +// ------------------------------------------------------------------- -class StreamPartHandshakeRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:StreamPartHandshakeRequest) */ { +class StreamPartHandshakeRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:StreamPartHandshakeRequest) */ { public: inline StreamPartHandshakeRequest() : StreamPartHandshakeRequest(nullptr) {} - ~StreamPartHandshakeRequest() override; - template - explicit PROTOBUF_CONSTEXPR StreamPartHandshakeRequest(::google::protobuf::internal::ConstantInitialized); + ~StreamPartHandshakeRequest() PROTOBUF_FINAL; - inline StreamPartHandshakeRequest(const StreamPartHandshakeRequest& from) - : StreamPartHandshakeRequest(nullptr, from) {} - StreamPartHandshakeRequest(StreamPartHandshakeRequest&& from) noexcept - : StreamPartHandshakeRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StreamPartHandshakeRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StreamPartHandshakeRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR StreamPartHandshakeRequest(::google::protobuf::internal::ConstantInitialized); + inline StreamPartHandshakeRequest(const StreamPartHandshakeRequest& from) : StreamPartHandshakeRequest(nullptr, from) {} + inline StreamPartHandshakeRequest(StreamPartHandshakeRequest&& from) noexcept + : StreamPartHandshakeRequest(nullptr, ::std::move(from)) {} inline StreamPartHandshakeRequest& operator=(const StreamPartHandshakeRequest& from) { CopyFrom(from); return *this; } inline StreamPartHandshakeRequest& operator=(StreamPartHandshakeRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -584,47 +634,35 @@ class StreamPartHandshakeRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StreamPartHandshakeRequest& default_instance() { - return *internal_default_instance(); - } - static inline const StreamPartHandshakeRequest* internal_default_instance() { - return reinterpret_cast( - &_StreamPartHandshakeRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(StreamPartHandshakeRequest& a, StreamPartHandshakeRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_StreamPartHandshakeRequest_default_instance_); } - inline void Swap(StreamPartHandshakeRequest* other) { + static constexpr int kIndexInFileMessages = 7; + friend void swap(StreamPartHandshakeRequest& a, StreamPartHandshakeRequest& b) { a.Swap(&b); } + inline void Swap(StreamPartHandshakeRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StreamPartHandshakeRequest* other) { + void UnsafeArenaSwap(StreamPartHandshakeRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -632,33 +670,40 @@ class StreamPartHandshakeRequest final : // implements Message ---------------------------------------------- - StreamPartHandshakeRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StreamPartHandshakeRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(StreamPartHandshakeRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "StreamPartHandshakeRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(StreamPartHandshakeRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "StreamPartHandshakeRequest"; } + + explicit StreamPartHandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StreamPartHandshakeRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamPartHandshakeRequest& from); + StreamPartHandshakeRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StreamPartHandshakeRequest&& from) noexcept + : StreamPartHandshakeRequest(arena) { + *this = ::std::move(from); } - protected: - explicit StreamPartHandshakeRequest(::google::protobuf::Arena* arena); - StreamPartHandshakeRequest(::google::protobuf::Arena* arena, const StreamPartHandshakeRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNeighborNodeIdsFieldNumber = 4, kStreamPartIdFieldNumber = 1, @@ -673,96 +718,91 @@ class StreamPartHandshakeRequest final : public: void clear_neighbornodeids() ; - const std::string& neighbornodeids(int index) const; - std::string* mutable_neighbornodeids(int index); - void set_neighbornodeids(int index, const std::string& value); - void set_neighbornodeids(int index, std::string&& value); - void set_neighbornodeids(int index, const char* value); - void set_neighbornodeids(int index, const void* value, std::size_t size); - void set_neighbornodeids(int index, absl::string_view value); - std::string* add_neighbornodeids(); - void add_neighbornodeids(const std::string& value); - void add_neighbornodeids(std::string&& value); - void add_neighbornodeids(const char* value); - void add_neighbornodeids(const void* value, std::size_t size); - void add_neighbornodeids(absl::string_view value); - const ::google::protobuf::RepeatedPtrField& neighbornodeids() const; - ::google::protobuf::RepeatedPtrField* mutable_neighbornodeids(); + const ::std::string& neighbornodeids(int index) const; + ::std::string* PROTOBUF_NONNULL mutable_neighbornodeids(int index); + template + void set_neighbornodeids(int index, Arg_&& value, Args_... args); + ::std::string* PROTOBUF_NONNULL add_neighbornodeids(); + template + void add_neighbornodeids(Arg_&& value, Args_... args); + const ::google::protobuf::RepeatedPtrField<::std::string>& neighbornodeids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_neighbornodeids(); private: - const ::google::protobuf::RepeatedPtrField& _internal_neighbornodeids() const; - ::google::protobuf::RepeatedPtrField* _internal_mutable_neighbornodeids(); + const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_neighbornodeids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_neighbornodeids(); public: // string streamPartId = 1; void clear_streampartid() ; - const std::string& streampartid() const; - template + const ::std::string& streampartid() const; + template void set_streampartid(Arg_&& arg, Args_... args); - std::string* mutable_streampartid(); - PROTOBUF_NODISCARD std::string* release_streampartid(); - void set_allocated_streampartid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_streampartid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_streampartid(); + void set_allocated_streampartid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_streampartid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_streampartid( - const std::string& value); - std::string* _internal_mutable_streampartid(); + const ::std::string& _internal_streampartid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_streampartid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_streampartid(); public: // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional bytes concurrentHandshakeNodeId = 3; bool has_concurrenthandshakenodeid() const; void clear_concurrenthandshakenodeid() ; - const std::string& concurrenthandshakenodeid() const; - template + const ::std::string& concurrenthandshakenodeid() const; + template void set_concurrenthandshakenodeid(Arg_&& arg, Args_... args); - std::string* mutable_concurrenthandshakenodeid(); - PROTOBUF_NODISCARD std::string* release_concurrenthandshakenodeid(); - void set_allocated_concurrenthandshakenodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_concurrenthandshakenodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_concurrenthandshakenodeid(); + void set_allocated_concurrenthandshakenodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_concurrenthandshakenodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_concurrenthandshakenodeid( - const std::string& value); - std::string* _internal_mutable_concurrenthandshakenodeid(); + const ::std::string& _internal_concurrenthandshakenodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_concurrenthandshakenodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_concurrenthandshakenodeid(); public: // optional bytes interleaveNodeId = 5; bool has_interleavenodeid() const; void clear_interleavenodeid() ; - const std::string& interleavenodeid() const; - template + const ::std::string& interleavenodeid() const; + template void set_interleavenodeid(Arg_&& arg, Args_... args); - std::string* mutable_interleavenodeid(); - PROTOBUF_NODISCARD std::string* release_interleavenodeid(); - void set_allocated_interleavenodeid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_interleavenodeid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_interleavenodeid(); + void set_allocated_interleavenodeid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_interleavenodeid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_interleavenodeid( - const std::string& value); - std::string* _internal_mutable_interleavenodeid(); + const ::std::string& _internal_interleavenodeid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_interleavenodeid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_interleavenodeid(); public: // @@protoc_insertion_point(class_scope:StreamPartHandshakeRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 0, 56, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -771,16 +811,17 @@ class StreamPartHandshakeRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const StreamPartHandshakeRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::RepeatedPtrField neighbornodeids_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField<::std::string> neighbornodeids_; ::google::protobuf::internal::ArenaStringPtr streampartid_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr concurrenthandshakenodeid_; @@ -789,34 +830,37 @@ class StreamPartHandshakeRequest final : }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StreamPartHandshakeRequest_class_data_; +// ------------------------------------------------------------------- -class ProxyConnectionResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ProxyConnectionResponse) */ { +class ProxyConnectionResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ProxyConnectionResponse) */ { public: inline ProxyConnectionResponse() : ProxyConnectionResponse(nullptr) {} - ~ProxyConnectionResponse() override; - template - explicit PROTOBUF_CONSTEXPR ProxyConnectionResponse(::google::protobuf::internal::ConstantInitialized); + ~ProxyConnectionResponse() PROTOBUF_FINAL; - inline ProxyConnectionResponse(const ProxyConnectionResponse& from) - : ProxyConnectionResponse(nullptr, from) {} - ProxyConnectionResponse(ProxyConnectionResponse&& from) noexcept - : ProxyConnectionResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ProxyConnectionResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ProxyConnectionResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ProxyConnectionResponse(::google::protobuf::internal::ConstantInitialized); + inline ProxyConnectionResponse(const ProxyConnectionResponse& from) : ProxyConnectionResponse(nullptr, from) {} + inline ProxyConnectionResponse(ProxyConnectionResponse&& from) noexcept + : ProxyConnectionResponse(nullptr, ::std::move(from)) {} inline ProxyConnectionResponse& operator=(const ProxyConnectionResponse& from) { CopyFrom(from); return *this; } inline ProxyConnectionResponse& operator=(ProxyConnectionResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -828,47 +872,35 @@ class ProxyConnectionResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ProxyConnectionResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ProxyConnectionResponse* internal_default_instance() { - return reinterpret_cast( - &_ProxyConnectionResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(ProxyConnectionResponse& a, ProxyConnectionResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_ProxyConnectionResponse_default_instance_); } - inline void Swap(ProxyConnectionResponse* other) { + static constexpr int kIndexInFileMessages = 14; + friend void swap(ProxyConnectionResponse& a, ProxyConnectionResponse& b) { a.Swap(&b); } + inline void Swap(ProxyConnectionResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ProxyConnectionResponse* other) { + void UnsafeArenaSwap(ProxyConnectionResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -876,33 +908,40 @@ class ProxyConnectionResponse final : // implements Message ---------------------------------------------- - ProxyConnectionResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ProxyConnectionResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ProxyConnectionResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ProxyConnectionResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ProxyConnectionResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ProxyConnectionResponse"; } + + explicit ProxyConnectionResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ProxyConnectionResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ProxyConnectionResponse& from); + ProxyConnectionResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ProxyConnectionResponse&& from) noexcept + : ProxyConnectionResponse(arena) { + *this = ::std::move(from); } - protected: - explicit ProxyConnectionResponse(::google::protobuf::Arena* arena); - ProxyConnectionResponse(::google::protobuf::Arena* arena, const ProxyConnectionResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kAcceptedFieldNumber = 1, }; @@ -919,6 +958,11 @@ class ProxyConnectionResponse final : // @@protoc_insertion_point(class_scope:ProxyConnectionResponse) 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; @@ -927,47 +971,52 @@ class ProxyConnectionResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ProxyConnectionResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; bool accepted_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class ProxyConnectionRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ProxyConnectionRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull ProxyConnectionResponse_class_data_; +// ------------------------------------------------------------------- + +class ProxyConnectionRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ProxyConnectionRequest) */ { public: inline ProxyConnectionRequest() : ProxyConnectionRequest(nullptr) {} - ~ProxyConnectionRequest() override; - template - explicit PROTOBUF_CONSTEXPR ProxyConnectionRequest(::google::protobuf::internal::ConstantInitialized); + ~ProxyConnectionRequest() PROTOBUF_FINAL; - inline ProxyConnectionRequest(const ProxyConnectionRequest& from) - : ProxyConnectionRequest(nullptr, from) {} - ProxyConnectionRequest(ProxyConnectionRequest&& from) noexcept - : ProxyConnectionRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ProxyConnectionRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ProxyConnectionRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR ProxyConnectionRequest(::google::protobuf::internal::ConstantInitialized); + + inline ProxyConnectionRequest(const ProxyConnectionRequest& from) : ProxyConnectionRequest(nullptr, from) {} + inline ProxyConnectionRequest(ProxyConnectionRequest&& from) noexcept + : ProxyConnectionRequest(nullptr, ::std::move(from)) {} inline ProxyConnectionRequest& operator=(const ProxyConnectionRequest& from) { CopyFrom(from); return *this; } inline ProxyConnectionRequest& operator=(ProxyConnectionRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -979,47 +1028,35 @@ class ProxyConnectionRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ProxyConnectionRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ProxyConnectionRequest_default_instance_); } - static inline const ProxyConnectionRequest* internal_default_instance() { - return reinterpret_cast( - &_ProxyConnectionRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(ProxyConnectionRequest& a, ProxyConnectionRequest& b) { - a.Swap(&b); - } - inline void Swap(ProxyConnectionRequest* other) { + static constexpr int kIndexInFileMessages = 13; + friend void swap(ProxyConnectionRequest& a, ProxyConnectionRequest& b) { a.Swap(&b); } + inline void Swap(ProxyConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ProxyConnectionRequest* other) { + void UnsafeArenaSwap(ProxyConnectionRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1027,51 +1064,57 @@ class ProxyConnectionRequest final : // implements Message ---------------------------------------------- - ProxyConnectionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ProxyConnectionRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ProxyConnectionRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ProxyConnectionRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ProxyConnectionRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ProxyConnectionRequest"; } + + explicit ProxyConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ProxyConnectionRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ProxyConnectionRequest& from); + ProxyConnectionRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ProxyConnectionRequest&& from) noexcept + : ProxyConnectionRequest(arena) { + *this = ::std::move(from); } - protected: - explicit ProxyConnectionRequest(::google::protobuf::Arena* arena); - ProxyConnectionRequest(::google::protobuf::Arena* arena, const ProxyConnectionRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kUserIdFieldNumber = 2, kDirectionFieldNumber = 1, }; // bytes userId = 2; void clear_userid() ; - const std::string& userid() const; - template + const ::std::string& userid() const; + template void set_userid(Arg_&& arg, Args_... args); - std::string* mutable_userid(); - PROTOBUF_NODISCARD std::string* release_userid(); - void set_allocated_userid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_userid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_userid(); + void set_allocated_userid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_userid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_userid( - const std::string& value); - std::string* _internal_mutable_userid(); + const ::std::string& _internal_userid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_userid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_userid(); public: // .ProxyDirection direction = 1; @@ -1087,6 +1130,11 @@ class ProxyConnectionRequest final : // @@protoc_insertion_point(class_scope:ProxyConnectionRequest) 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; @@ -1095,47 +1143,52 @@ class ProxyConnectionRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ProxyConnectionRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr userid_; int direction_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ProxyConnectionRequest_class_data_; +// ------------------------------------------------------------------- -class NodeInfoRequest final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:NodeInfoRequest) */ { +class NodeInfoRequest final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:NodeInfoRequest) */ { public: inline NodeInfoRequest() : NodeInfoRequest(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR NodeInfoRequest(::google::protobuf::internal::ConstantInitialized); - inline NodeInfoRequest(const NodeInfoRequest& from) - : NodeInfoRequest(nullptr, from) {} - NodeInfoRequest(NodeInfoRequest&& from) noexcept - : NodeInfoRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(NodeInfoRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(NodeInfoRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR NodeInfoRequest(::google::protobuf::internal::ConstantInitialized); + inline NodeInfoRequest(const NodeInfoRequest& from) : NodeInfoRequest(nullptr, from) {} + inline NodeInfoRequest(NodeInfoRequest&& from) noexcept + : NodeInfoRequest(nullptr, ::std::move(from)) {} inline NodeInfoRequest& operator=(const NodeInfoRequest& from) { CopyFrom(from); return *this; } inline NodeInfoRequest& operator=(NodeInfoRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1147,47 +1200,35 @@ class NodeInfoRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const NodeInfoRequest& default_instance() { - return *internal_default_instance(); - } - static inline const NodeInfoRequest* internal_default_instance() { - return reinterpret_cast( - &_NodeInfoRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(NodeInfoRequest& a, NodeInfoRequest& b) { - a.Swap(&b); + return *reinterpret_cast( + &_NodeInfoRequest_default_instance_); } - inline void Swap(NodeInfoRequest* other) { + static constexpr int kIndexInFileMessages = 20; + friend void swap(NodeInfoRequest& a, NodeInfoRequest& b) { a.Swap(&b); } + inline void Swap(NodeInfoRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(NodeInfoRequest* other) { + void UnsafeArenaSwap(NodeInfoRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1195,29 +1236,42 @@ class NodeInfoRequest final : // implements Message ---------------------------------------------- - NodeInfoRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + NodeInfoRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "NodeInfoRequest"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "NodeInfoRequest"; } + + explicit NodeInfoRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + NodeInfoRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeInfoRequest& from); + NodeInfoRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NodeInfoRequest&& from) noexcept + : NodeInfoRequest(arena) { + *this = ::std::move(from); } - protected: - explicit NodeInfoRequest(::google::protobuf::Arena* arena); - NodeInfoRequest(::google::protobuf::Arena* arena, const NodeInfoRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:NodeInfoRequest) 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; @@ -1225,45 +1279,38 @@ class NodeInfoRequest final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull NodeInfoRequest_class_data_; +// ------------------------------------------------------------------- -class MessageRef final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:MessageRef) */ { +class MessageRef final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:MessageRef) */ { public: inline MessageRef() : MessageRef(nullptr) {} - ~MessageRef() override; - template - explicit PROTOBUF_CONSTEXPR MessageRef(::google::protobuf::internal::ConstantInitialized); + ~MessageRef() PROTOBUF_FINAL; - inline MessageRef(const MessageRef& from) - : MessageRef(nullptr, from) {} - MessageRef(MessageRef&& from) noexcept - : MessageRef() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(MessageRef* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(MessageRef)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR MessageRef(::google::protobuf::internal::ConstantInitialized); + inline MessageRef(const MessageRef& from) : MessageRef(nullptr, from) {} + inline MessageRef(MessageRef&& from) noexcept + : MessageRef(nullptr, ::std::move(from)) {} inline MessageRef& operator=(const MessageRef& from) { CopyFrom(from); return *this; } inline MessageRef& operator=(MessageRef&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1275,47 +1322,35 @@ class MessageRef final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const MessageRef& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_MessageRef_default_instance_); } - static inline const MessageRef* internal_default_instance() { - return reinterpret_cast( - &_MessageRef_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(MessageRef& a, MessageRef& b) { - a.Swap(&b); - } - inline void Swap(MessageRef* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(MessageRef& a, MessageRef& b) { a.Swap(&b); } + inline void Swap(MessageRef* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MessageRef* other) { + void UnsafeArenaSwap(MessageRef* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1323,33 +1358,40 @@ class MessageRef final : // implements Message ---------------------------------------------- - MessageRef* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + MessageRef* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(MessageRef* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "MessageRef"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(MessageRef* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "MessageRef"; } + + explicit MessageRef(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + MessageRef(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MessageRef& from); + MessageRef( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, MessageRef&& from) noexcept + : MessageRef(arena) { + *this = ::std::move(from); } - protected: - explicit MessageRef(::google::protobuf::Arena* arena); - MessageRef(::google::protobuf::Arena* arena, const MessageRef& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kTimestampFieldNumber = 1, kSequenceNumberFieldNumber = 2, @@ -1377,6 +1419,11 @@ class MessageRef final : // @@protoc_insertion_point(class_scope:MessageRef) 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; @@ -1385,48 +1432,53 @@ class MessageRef final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const MessageRef& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::int64_t timestamp_; ::int32_t sequencenumber_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull MessageRef_class_data_; +// ------------------------------------------------------------------- -class MessageID final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:MessageID) */ { +class MessageID final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:MessageID) */ { public: inline MessageID() : MessageID(nullptr) {} - ~MessageID() override; - template - explicit PROTOBUF_CONSTEXPR MessageID(::google::protobuf::internal::ConstantInitialized); + ~MessageID() PROTOBUF_FINAL; - inline MessageID(const MessageID& from) - : MessageID(nullptr, from) {} - MessageID(MessageID&& from) noexcept - : MessageID() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(MessageID* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(MessageID)); } +#endif + template + explicit PROTOBUF_CONSTEXPR MessageID(::google::protobuf::internal::ConstantInitialized); + + inline MessageID(const MessageID& from) : MessageID(nullptr, from) {} + inline MessageID(MessageID&& from) noexcept + : MessageID(nullptr, ::std::move(from)) {} inline MessageID& operator=(const MessageID& from) { CopyFrom(from); return *this; } inline MessageID& operator=(MessageID&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1438,47 +1490,35 @@ class MessageID final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const MessageID& default_instance() { - return *internal_default_instance(); - } - static inline const MessageID* internal_default_instance() { - return reinterpret_cast( - &_MessageID_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(MessageID& a, MessageID& b) { - a.Swap(&b); + return *reinterpret_cast( + &_MessageID_default_instance_); } - inline void Swap(MessageID* other) { + static constexpr int kIndexInFileMessages = 0; + friend void swap(MessageID& a, MessageID& b) { a.Swap(&b); } + inline void Swap(MessageID* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MessageID* other) { + void UnsafeArenaSwap(MessageID* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1486,33 +1526,40 @@ class MessageID final : // implements Message ---------------------------------------------- - MessageID* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + MessageID* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(MessageID* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "MessageID"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(MessageID* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "MessageID"; } + + explicit MessageID(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + MessageID(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MessageID& from); + MessageID( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, MessageID&& from) noexcept + : MessageID(arena) { + *this = ::std::move(from); } - protected: - explicit MessageID(::google::protobuf::Arena* arena); - MessageID(::google::protobuf::Arena* arena, const MessageID& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kStreamIdFieldNumber = 1, kPublisherIdFieldNumber = 5, @@ -1523,50 +1570,47 @@ class MessageID final : }; // string streamId = 1; void clear_streamid() ; - const std::string& streamid() const; - template + const ::std::string& streamid() const; + template void set_streamid(Arg_&& arg, Args_... args); - std::string* mutable_streamid(); - PROTOBUF_NODISCARD std::string* release_streamid(); - void set_allocated_streamid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_streamid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_streamid(); + void set_allocated_streamid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_streamid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamid( - const std::string& value); - std::string* _internal_mutable_streamid(); + const ::std::string& _internal_streamid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_streamid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_streamid(); public: // bytes publisherId = 5; void clear_publisherid() ; - const std::string& publisherid() const; - template + const ::std::string& publisherid() const; + template void set_publisherid(Arg_&& arg, Args_... args); - std::string* mutable_publisherid(); - PROTOBUF_NODISCARD std::string* release_publisherid(); - void set_allocated_publisherid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_publisherid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_publisherid(); + void set_allocated_publisherid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_publisherid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_publisherid( - const std::string& value); - std::string* _internal_mutable_publisherid(); + const ::std::string& _internal_publisherid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_publisherid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_publisherid(); public: // string messageChainId = 6; void clear_messagechainid() ; - const std::string& messagechainid() const; - template + const ::std::string& messagechainid() const; + template void set_messagechainid(Arg_&& arg, Args_... args); - std::string* mutable_messagechainid(); - PROTOBUF_NODISCARD std::string* release_messagechainid(); - void set_allocated_messagechainid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_messagechainid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_messagechainid(); + void set_allocated_messagechainid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_messagechainid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagechainid( - const std::string& value); - std::string* _internal_mutable_messagechainid(); + const ::std::string& _internal_messagechainid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_messagechainid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_messagechainid(); public: // int64 timestamp = 3; @@ -1602,6 +1646,11 @@ class MessageID final : // @@protoc_insertion_point(class_scope:MessageID) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 6, + 0, 40, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1610,52 +1659,57 @@ class MessageID final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const MessageID& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr streamid_; ::google::protobuf::internal::ArenaStringPtr publisherid_; ::google::protobuf::internal::ArenaStringPtr messagechainid_; ::int64_t timestamp_; ::int32_t streampartition_; ::int32_t sequencenumber_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull MessageID_class_data_; +// ------------------------------------------------------------------- -class LeaveStreamPartNotice final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:LeaveStreamPartNotice) */ { +class LeaveStreamPartNotice final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:LeaveStreamPartNotice) */ { public: inline LeaveStreamPartNotice() : LeaveStreamPartNotice(nullptr) {} - ~LeaveStreamPartNotice() override; - template - explicit PROTOBUF_CONSTEXPR LeaveStreamPartNotice(::google::protobuf::internal::ConstantInitialized); + ~LeaveStreamPartNotice() PROTOBUF_FINAL; - inline LeaveStreamPartNotice(const LeaveStreamPartNotice& from) - : LeaveStreamPartNotice(nullptr, from) {} - LeaveStreamPartNotice(LeaveStreamPartNotice&& from) noexcept - : LeaveStreamPartNotice() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LeaveStreamPartNotice* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LeaveStreamPartNotice)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR LeaveStreamPartNotice(::google::protobuf::internal::ConstantInitialized); + inline LeaveStreamPartNotice(const LeaveStreamPartNotice& from) : LeaveStreamPartNotice(nullptr, from) {} + inline LeaveStreamPartNotice(LeaveStreamPartNotice&& from) noexcept + : LeaveStreamPartNotice(nullptr, ::std::move(from)) {} inline LeaveStreamPartNotice& operator=(const LeaveStreamPartNotice& from) { CopyFrom(from); return *this; } inline LeaveStreamPartNotice& operator=(LeaveStreamPartNotice&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1667,47 +1721,35 @@ class LeaveStreamPartNotice final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const LeaveStreamPartNotice& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_LeaveStreamPartNotice_default_instance_); } - static inline const LeaveStreamPartNotice* internal_default_instance() { - return reinterpret_cast( - &_LeaveStreamPartNotice_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(LeaveStreamPartNotice& a, LeaveStreamPartNotice& b) { - a.Swap(&b); - } - inline void Swap(LeaveStreamPartNotice* other) { + static constexpr int kIndexInFileMessages = 11; + friend void swap(LeaveStreamPartNotice& a, LeaveStreamPartNotice& b) { a.Swap(&b); } + inline void Swap(LeaveStreamPartNotice* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(LeaveStreamPartNotice* other) { + void UnsafeArenaSwap(LeaveStreamPartNotice* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1715,51 +1757,57 @@ class LeaveStreamPartNotice final : // implements Message ---------------------------------------------- - LeaveStreamPartNotice* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + LeaveStreamPartNotice* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(LeaveStreamPartNotice* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "LeaveStreamPartNotice"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(LeaveStreamPartNotice* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "LeaveStreamPartNotice"; } + + explicit LeaveStreamPartNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + LeaveStreamPartNotice(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LeaveStreamPartNotice& from); + LeaveStreamPartNotice( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LeaveStreamPartNotice&& from) noexcept + : LeaveStreamPartNotice(arena) { + *this = ::std::move(from); } - protected: - explicit LeaveStreamPartNotice(::google::protobuf::Arena* arena); - LeaveStreamPartNotice(::google::protobuf::Arena* arena, const LeaveStreamPartNotice& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kStreamPartIdFieldNumber = 1, kIsEntryPointFieldNumber = 2, }; // string streamPartId = 1; void clear_streampartid() ; - const std::string& streampartid() const; - template + const ::std::string& streampartid() const; + template void set_streampartid(Arg_&& arg, Args_... args); - std::string* mutable_streampartid(); - PROTOBUF_NODISCARD std::string* release_streampartid(); - void set_allocated_streampartid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_streampartid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_streampartid(); + void set_allocated_streampartid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_streampartid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_streampartid( - const std::string& value); - std::string* _internal_mutable_streampartid(); + const ::std::string& _internal_streampartid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_streampartid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_streampartid(); public: // bool isEntryPoint = 2; @@ -1775,6 +1823,11 @@ class LeaveStreamPartNotice final : // @@protoc_insertion_point(class_scope:LeaveStreamPartNotice) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 42, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -1783,48 +1836,53 @@ class LeaveStreamPartNotice final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const LeaveStreamPartNotice& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr streampartid_; bool isentrypoint_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull LeaveStreamPartNotice_class_data_; +// ------------------------------------------------------------------- -class InterleaveResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:InterleaveResponse) */ { +class InterleaveResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:InterleaveResponse) */ { public: inline InterleaveResponse() : InterleaveResponse(nullptr) {} - ~InterleaveResponse() override; - template - explicit PROTOBUF_CONSTEXPR InterleaveResponse(::google::protobuf::internal::ConstantInitialized); + ~InterleaveResponse() PROTOBUF_FINAL; - inline InterleaveResponse(const InterleaveResponse& from) - : InterleaveResponse(nullptr, from) {} - InterleaveResponse(InterleaveResponse&& from) noexcept - : InterleaveResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(InterleaveResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(InterleaveResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR InterleaveResponse(::google::protobuf::internal::ConstantInitialized); + inline InterleaveResponse(const InterleaveResponse& from) : InterleaveResponse(nullptr, from) {} + inline InterleaveResponse(InterleaveResponse&& from) noexcept + : InterleaveResponse(nullptr, ::std::move(from)) {} inline InterleaveResponse& operator=(const InterleaveResponse& from) { CopyFrom(from); return *this; } inline InterleaveResponse& operator=(InterleaveResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1836,47 +1894,35 @@ class InterleaveResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const InterleaveResponse& default_instance() { - return *internal_default_instance(); - } - static inline const InterleaveResponse* internal_default_instance() { - return reinterpret_cast( - &_InterleaveResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(InterleaveResponse& a, InterleaveResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_InterleaveResponse_default_instance_); } - inline void Swap(InterleaveResponse* other) { + static constexpr int kIndexInFileMessages = 10; + friend void swap(InterleaveResponse& a, InterleaveResponse& b) { a.Swap(&b); } + inline void Swap(InterleaveResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(InterleaveResponse* other) { + void UnsafeArenaSwap(InterleaveResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1884,33 +1930,40 @@ class InterleaveResponse final : // implements Message ---------------------------------------------- - InterleaveResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + InterleaveResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(InterleaveResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "InterleaveResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(InterleaveResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "InterleaveResponse"; } + + explicit InterleaveResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + InterleaveResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const InterleaveResponse& from); + InterleaveResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, InterleaveResponse&& from) noexcept + : InterleaveResponse(arena) { + *this = ::std::move(from); } - protected: - explicit InterleaveResponse(::google::protobuf::Arena* arena); - InterleaveResponse(::google::protobuf::Arena* arena, const InterleaveResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kAcceptedFieldNumber = 1, }; @@ -1927,6 +1980,11 @@ class InterleaveResponse final : // @@protoc_insertion_point(class_scope:InterleaveResponse) 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; @@ -1935,47 +1993,52 @@ class InterleaveResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const InterleaveResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; bool accepted_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class GroupKeyRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:GroupKeyRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull InterleaveResponse_class_data_; +// ------------------------------------------------------------------- + +class GroupKeyRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:GroupKeyRequest) */ { public: inline GroupKeyRequest() : GroupKeyRequest(nullptr) {} - ~GroupKeyRequest() override; - template - explicit PROTOBUF_CONSTEXPR GroupKeyRequest(::google::protobuf::internal::ConstantInitialized); + ~GroupKeyRequest() PROTOBUF_FINAL; - inline GroupKeyRequest(const GroupKeyRequest& from) - : GroupKeyRequest(nullptr, from) {} - GroupKeyRequest(GroupKeyRequest&& from) noexcept - : GroupKeyRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GroupKeyRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GroupKeyRequest)); } +#endif + template + explicit PROTOBUF_CONSTEXPR GroupKeyRequest(::google::protobuf::internal::ConstantInitialized); + + inline GroupKeyRequest(const GroupKeyRequest& from) : GroupKeyRequest(nullptr, from) {} + inline GroupKeyRequest(GroupKeyRequest&& from) noexcept + : GroupKeyRequest(nullptr, ::std::move(from)) {} inline GroupKeyRequest& operator=(const GroupKeyRequest& from) { CopyFrom(from); return *this; } inline GroupKeyRequest& operator=(GroupKeyRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -1987,47 +2050,35 @@ class GroupKeyRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const GroupKeyRequest& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_GroupKeyRequest_default_instance_); } - static inline const GroupKeyRequest* internal_default_instance() { - return reinterpret_cast( - &_GroupKeyRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(GroupKeyRequest& a, GroupKeyRequest& b) { - a.Swap(&b); - } - inline void Swap(GroupKeyRequest* other) { + static constexpr int kIndexInFileMessages = 4; + friend void swap(GroupKeyRequest& a, GroupKeyRequest& b) { a.Swap(&b); } + inline void Swap(GroupKeyRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(GroupKeyRequest* other) { + void UnsafeArenaSwap(GroupKeyRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2035,33 +2086,40 @@ class GroupKeyRequest final : // implements Message ---------------------------------------------- - GroupKeyRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + GroupKeyRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(GroupKeyRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "GroupKeyRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GroupKeyRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "GroupKeyRequest"; } + + explicit GroupKeyRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + GroupKeyRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GroupKeyRequest& from); + GroupKeyRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GroupKeyRequest&& from) noexcept + : GroupKeyRequest(arena) { + *this = ::std::move(from); } - protected: - explicit GroupKeyRequest(::google::protobuf::Arena* arena); - GroupKeyRequest(::google::protobuf::Arena* arena, const GroupKeyRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kGroupKeyIdsFieldNumber = 4, kRequestIdFieldNumber = 1, @@ -2075,78 +2133,74 @@ class GroupKeyRequest final : public: void clear_groupkeyids() ; - const std::string& groupkeyids(int index) const; - std::string* mutable_groupkeyids(int index); - void set_groupkeyids(int index, const std::string& value); - void set_groupkeyids(int index, std::string&& value); - void set_groupkeyids(int index, const char* value); - void set_groupkeyids(int index, const char* value, std::size_t size); - void set_groupkeyids(int index, absl::string_view value); - std::string* add_groupkeyids(); - void add_groupkeyids(const std::string& value); - void add_groupkeyids(std::string&& value); - void add_groupkeyids(const char* value); - void add_groupkeyids(const char* value, std::size_t size); - void add_groupkeyids(absl::string_view value); - const ::google::protobuf::RepeatedPtrField& groupkeyids() const; - ::google::protobuf::RepeatedPtrField* mutable_groupkeyids(); + const ::std::string& groupkeyids(int index) const; + ::std::string* PROTOBUF_NONNULL mutable_groupkeyids(int index); + template + void set_groupkeyids(int index, Arg_&& value, Args_... args); + ::std::string* PROTOBUF_NONNULL add_groupkeyids(); + template + void add_groupkeyids(Arg_&& value, Args_... args); + const ::google::protobuf::RepeatedPtrField<::std::string>& groupkeyids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_groupkeyids(); private: - const ::google::protobuf::RepeatedPtrField& _internal_groupkeyids() const; - ::google::protobuf::RepeatedPtrField* _internal_mutable_groupkeyids(); + const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_groupkeyids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_groupkeyids(); public: // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // bytes recipientId = 2; void clear_recipientid() ; - const std::string& recipientid() const; - template + const ::std::string& recipientid() const; + template void set_recipientid(Arg_&& arg, Args_... args); - std::string* mutable_recipientid(); - PROTOBUF_NODISCARD std::string* release_recipientid(); - void set_allocated_recipientid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_recipientid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_recipientid(); + void set_allocated_recipientid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_recipientid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_recipientid( - const std::string& value); - std::string* _internal_mutable_recipientid(); + const ::std::string& _internal_recipientid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_recipientid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_recipientid(); public: // bytes rsaPublicKey = 3; void clear_rsapublickey() ; - const std::string& rsapublickey() const; - template + const ::std::string& rsapublickey() const; + template void set_rsapublickey(Arg_&& arg, Args_... args); - std::string* mutable_rsapublickey(); - PROTOBUF_NODISCARD std::string* release_rsapublickey(); - void set_allocated_rsapublickey(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_rsapublickey(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_rsapublickey(); + void set_allocated_rsapublickey(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_rsapublickey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_rsapublickey( - const std::string& value); - std::string* _internal_mutable_rsapublickey(); + const ::std::string& _internal_rsapublickey() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_rsapublickey(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_rsapublickey(); public: // @@protoc_insertion_point(class_scope:GroupKeyRequest) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 0, 44, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2155,50 +2209,55 @@ class GroupKeyRequest final : 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); - ::google::protobuf::RepeatedPtrField groupkeyids_; + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const GroupKeyRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField<::std::string> groupkeyids_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr recipientid_; ::google::protobuf::internal::ArenaStringPtr rsapublickey_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull GroupKeyRequest_class_data_; +// ------------------------------------------------------------------- -class GroupKey final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:GroupKey) */ { +class GroupKey final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:GroupKey) */ { public: inline GroupKey() : GroupKey(nullptr) {} - ~GroupKey() override; - template - explicit PROTOBUF_CONSTEXPR GroupKey(::google::protobuf::internal::ConstantInitialized); + ~GroupKey() PROTOBUF_FINAL; - inline GroupKey(const GroupKey& from) - : GroupKey(nullptr, from) {} - GroupKey(GroupKey&& from) noexcept - : GroupKey() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GroupKey* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GroupKey)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR GroupKey(::google::protobuf::internal::ConstantInitialized); + inline GroupKey(const GroupKey& from) : GroupKey(nullptr, from) {} + inline GroupKey(GroupKey&& from) noexcept + : GroupKey(nullptr, ::std::move(from)) {} inline GroupKey& operator=(const GroupKey& from) { CopyFrom(from); return *this; } inline GroupKey& operator=(GroupKey&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2210,47 +2269,35 @@ class GroupKey final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const GroupKey& default_instance() { - return *internal_default_instance(); - } - static inline const GroupKey* internal_default_instance() { - return reinterpret_cast( - &_GroupKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(GroupKey& a, GroupKey& b) { - a.Swap(&b); + return *reinterpret_cast( + &_GroupKey_default_instance_); } - inline void Swap(GroupKey* other) { + static constexpr int kIndexInFileMessages = 6; + friend void swap(GroupKey& a, GroupKey& b) { a.Swap(&b); } + inline void Swap(GroupKey* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(GroupKey* other) { + void UnsafeArenaSwap(GroupKey* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2258,72 +2305,82 @@ class GroupKey final : // implements Message ---------------------------------------------- - GroupKey* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + GroupKey* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(GroupKey* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "GroupKey"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GroupKey* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "GroupKey"; } + + explicit GroupKey(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + GroupKey(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GroupKey& from); + GroupKey( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GroupKey&& from) noexcept + : GroupKey(arena) { + *this = ::std::move(from); } - protected: - explicit GroupKey(::google::protobuf::Arena* arena); - GroupKey(::google::protobuf::Arena* arena, const GroupKey& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kIdFieldNumber = 1, kDataFieldNumber = 2, }; // string id = 1; void clear_id() ; - const std::string& id() const; - template + const ::std::string& id() const; + template void set_id(Arg_&& arg, Args_... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_id(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_id(); + void set_allocated_id(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id( - const std::string& value); - std::string* _internal_mutable_id(); + const ::std::string& _internal_id() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_id(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_id(); public: // bytes data = 2; void clear_data() ; - const std::string& data() const; - template + 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); + ::std::string* PROTOBUF_NONNULL mutable_data(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_data(); + void set_allocated_data(::std::string* PROTOBUF_NULLABLE 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(); + const ::std::string& _internal_data() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_data(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_data(); public: // @@protoc_insertion_point(class_scope:GroupKey) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 19, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2332,47 +2389,52 @@ class GroupKey final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const GroupKey& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr id_; ::google::protobuf::internal::ArenaStringPtr data_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class CloseTemporaryConnection final : - public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CloseTemporaryConnection) */ { +extern const ::google::protobuf::internal::ClassDataFull GroupKey_class_data_; +// ------------------------------------------------------------------- + +class CloseTemporaryConnection final : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:CloseTemporaryConnection) */ { public: inline CloseTemporaryConnection() : CloseTemporaryConnection(nullptr) {} - template - explicit PROTOBUF_CONSTEXPR CloseTemporaryConnection(::google::protobuf::internal::ConstantInitialized); - inline CloseTemporaryConnection(const CloseTemporaryConnection& from) - : CloseTemporaryConnection(nullptr, from) {} - CloseTemporaryConnection(CloseTemporaryConnection&& from) noexcept - : CloseTemporaryConnection() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CloseTemporaryConnection* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CloseTemporaryConnection)); } +#endif + template + explicit PROTOBUF_CONSTEXPR CloseTemporaryConnection(::google::protobuf::internal::ConstantInitialized); + + inline CloseTemporaryConnection(const CloseTemporaryConnection& from) : CloseTemporaryConnection(nullptr, from) {} + inline CloseTemporaryConnection(CloseTemporaryConnection&& from) noexcept + : CloseTemporaryConnection(nullptr, ::std::move(from)) {} inline CloseTemporaryConnection& operator=(const CloseTemporaryConnection& from) { CopyFrom(from); return *this; } inline CloseTemporaryConnection& operator=(CloseTemporaryConnection&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2384,47 +2446,35 @@ class CloseTemporaryConnection final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const CloseTemporaryConnection& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_CloseTemporaryConnection_default_instance_); } - static inline const CloseTemporaryConnection* internal_default_instance() { - return reinterpret_cast( - &_CloseTemporaryConnection_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(CloseTemporaryConnection& a, CloseTemporaryConnection& b) { - a.Swap(&b); - } - inline void Swap(CloseTemporaryConnection* other) { + static constexpr int kIndexInFileMessages = 17; + friend void swap(CloseTemporaryConnection& a, CloseTemporaryConnection& b) { a.Swap(&b); } + inline void Swap(CloseTemporaryConnection* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(CloseTemporaryConnection* other) { + void UnsafeArenaSwap(CloseTemporaryConnection* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2432,29 +2482,42 @@ class CloseTemporaryConnection final : // implements Message ---------------------------------------------- - CloseTemporaryConnection* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + CloseTemporaryConnection* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "CloseTemporaryConnection"; + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "CloseTemporaryConnection"; } + + explicit CloseTemporaryConnection(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + CloseTemporaryConnection(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CloseTemporaryConnection& from); + CloseTemporaryConnection( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CloseTemporaryConnection&& from) noexcept + : CloseTemporaryConnection(arena) { + *this = ::std::move(from); } - protected: - explicit CloseTemporaryConnection(::google::protobuf::Arena* arena); - CloseTemporaryConnection(::google::protobuf::Arena* arena, const CloseTemporaryConnection& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:CloseTemporaryConnection) 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; @@ -2462,45 +2525,38 @@ class CloseTemporaryConnection final : 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); - PROTOBUF_TSAN_DECLARE_MEMBER - }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class GroupKeyResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:GroupKeyResponse) */ { +extern const ::google::protobuf::internal::ClassDataFull CloseTemporaryConnection_class_data_; +// ------------------------------------------------------------------- + +class GroupKeyResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:GroupKeyResponse) */ { public: inline GroupKeyResponse() : GroupKeyResponse(nullptr) {} - ~GroupKeyResponse() override; - template - explicit PROTOBUF_CONSTEXPR GroupKeyResponse(::google::protobuf::internal::ConstantInitialized); + ~GroupKeyResponse() PROTOBUF_FINAL; - inline GroupKeyResponse(const GroupKeyResponse& from) - : GroupKeyResponse(nullptr, from) {} - GroupKeyResponse(GroupKeyResponse&& from) noexcept - : GroupKeyResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GroupKeyResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GroupKeyResponse)); } +#endif + template + explicit PROTOBUF_CONSTEXPR GroupKeyResponse(::google::protobuf::internal::ConstantInitialized); + + inline GroupKeyResponse(const GroupKeyResponse& from) : GroupKeyResponse(nullptr, from) {} + inline GroupKeyResponse(GroupKeyResponse&& from) noexcept + : GroupKeyResponse(nullptr, ::std::move(from)) {} inline GroupKeyResponse& operator=(const GroupKeyResponse& from) { CopyFrom(from); return *this; } inline GroupKeyResponse& operator=(GroupKeyResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2512,47 +2568,35 @@ class GroupKeyResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const GroupKeyResponse& default_instance() { - return *internal_default_instance(); - } - static inline const GroupKeyResponse* internal_default_instance() { - return reinterpret_cast( - &_GroupKeyResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(GroupKeyResponse& a, GroupKeyResponse& b) { - a.Swap(&b); + return *reinterpret_cast( + &_GroupKeyResponse_default_instance_); } - inline void Swap(GroupKeyResponse* other) { + static constexpr int kIndexInFileMessages = 5; + friend void swap(GroupKeyResponse& a, GroupKeyResponse& b) { a.Swap(&b); } + inline void Swap(GroupKeyResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(GroupKeyResponse* other) { + void UnsafeArenaSwap(GroupKeyResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2560,33 +2604,40 @@ class GroupKeyResponse final : // implements Message ---------------------------------------------- - GroupKeyResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + GroupKeyResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(GroupKeyResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "GroupKeyResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GroupKeyResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "GroupKeyResponse"; } + + explicit GroupKeyResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + GroupKeyResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GroupKeyResponse& from); + GroupKeyResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GroupKeyResponse&& from) noexcept + : GroupKeyResponse(arena) { + *this = ::std::move(from); } - protected: - explicit GroupKeyResponse(::google::protobuf::Arena* arena); - GroupKeyResponse(::google::protobuf::Arena* arena, const GroupKeyResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kGroupKeysFieldNumber = 3, kRequestIdFieldNumber = 1, @@ -2599,52 +2650,54 @@ class GroupKeyResponse final : public: void clear_groupkeys() ; - ::GroupKey* mutable_groupkeys(int index); - ::google::protobuf::RepeatedPtrField< ::GroupKey >* - mutable_groupkeys(); + ::GroupKey* PROTOBUF_NONNULL mutable_groupkeys(int index); + ::google::protobuf::RepeatedPtrField<::GroupKey>* PROTOBUF_NONNULL mutable_groupkeys(); + private: const ::google::protobuf::RepeatedPtrField<::GroupKey>& _internal_groupkeys() const; - ::google::protobuf::RepeatedPtrField<::GroupKey>* _internal_mutable_groupkeys(); + ::google::protobuf::RepeatedPtrField<::GroupKey>* PROTOBUF_NONNULL _internal_mutable_groupkeys(); public: const ::GroupKey& groupkeys(int index) const; - ::GroupKey* add_groupkeys(); - const ::google::protobuf::RepeatedPtrField< ::GroupKey >& - groupkeys() const; + ::GroupKey* PROTOBUF_NONNULL add_groupkeys(); + const ::google::protobuf::RepeatedPtrField<::GroupKey>& groupkeys() const; // string requestId = 1; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // bytes recipientId = 2; void clear_recipientid() ; - const std::string& recipientid() const; - template + const ::std::string& recipientid() const; + template void set_recipientid(Arg_&& arg, Args_... args); - std::string* mutable_recipientid(); - PROTOBUF_NODISCARD std::string* release_recipientid(); - void set_allocated_recipientid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_recipientid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_recipientid(); + void set_allocated_recipientid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_recipientid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_recipientid( - const std::string& value); - std::string* _internal_mutable_recipientid(); + const ::std::string& _internal_recipientid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_recipientid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_recipientid(); public: // @@protoc_insertion_point(class_scope:GroupKeyResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 1, 34, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2653,49 +2706,54 @@ class GroupKeyResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const GroupKeyResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::GroupKey > groupkeys_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr recipientid_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull GroupKeyResponse_class_data_; +// ------------------------------------------------------------------- -class ContentMessage final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ContentMessage) */ { +class ContentMessage final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ContentMessage) */ { public: inline ContentMessage() : ContentMessage(nullptr) {} - ~ContentMessage() override; - template - explicit PROTOBUF_CONSTEXPR ContentMessage(::google::protobuf::internal::ConstantInitialized); + ~ContentMessage() PROTOBUF_FINAL; - inline ContentMessage(const ContentMessage& from) - : ContentMessage(nullptr, from) {} - ContentMessage(ContentMessage&& from) noexcept - : ContentMessage() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ContentMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ContentMessage)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ContentMessage(::google::protobuf::internal::ConstantInitialized); + inline ContentMessage(const ContentMessage& from) : ContentMessage(nullptr, from) {} + inline ContentMessage(ContentMessage&& from) noexcept + : ContentMessage(nullptr, ::std::move(from)) {} inline ContentMessage& operator=(const ContentMessage& from) { CopyFrom(from); return *this; } inline ContentMessage& operator=(ContentMessage&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2707,47 +2765,35 @@ class ContentMessage final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ContentMessage& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ContentMessage_default_instance_); } - static inline const ContentMessage* internal_default_instance() { - return reinterpret_cast( - &_ContentMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(ContentMessage& a, ContentMessage& b) { - a.Swap(&b); - } - inline void Swap(ContentMessage* other) { + static constexpr int kIndexInFileMessages = 3; + friend void swap(ContentMessage& a, ContentMessage& b) { a.Swap(&b); } + inline void Swap(ContentMessage* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ContentMessage* other) { + void UnsafeArenaSwap(ContentMessage* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2755,33 +2801,40 @@ class ContentMessage final : // implements Message ---------------------------------------------- - ContentMessage* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ContentMessage* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ContentMessage* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ContentMessage"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ContentMessage* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ContentMessage"; } + + explicit ContentMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ContentMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ContentMessage& from); + ContentMessage( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ContentMessage&& from) noexcept + : ContentMessage(arena) { + *this = ::std::move(from); } - protected: - explicit ContentMessage(::google::protobuf::Arena* arena); - ContentMessage(::google::protobuf::Arena* arena, const ContentMessage& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kContentFieldNumber = 1, kGroupKeyIdFieldNumber = 4, @@ -2791,50 +2844,48 @@ class ContentMessage final : }; // bytes content = 1; void clear_content() ; - const std::string& content() const; - template + const ::std::string& content() const; + template void set_content(Arg_&& arg, Args_... args); - std::string* mutable_content(); - PROTOBUF_NODISCARD std::string* release_content(); - void set_allocated_content(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_content(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_content(); + void set_allocated_content(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_content() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_content( - const std::string& value); - std::string* _internal_mutable_content(); + const ::std::string& _internal_content() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_content(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_content(); public: // optional string groupKeyId = 4; bool has_groupkeyid() const; void clear_groupkeyid() ; - const std::string& groupkeyid() const; - template + const ::std::string& groupkeyid() const; + template void set_groupkeyid(Arg_&& arg, Args_... args); - std::string* mutable_groupkeyid(); - PROTOBUF_NODISCARD std::string* release_groupkeyid(); - void set_allocated_groupkeyid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_groupkeyid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_groupkeyid(); + void set_allocated_groupkeyid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_groupkeyid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupkeyid( - const std::string& value); - std::string* _internal_mutable_groupkeyid(); + const ::std::string& _internal_groupkeyid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_groupkeyid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_groupkeyid(); public: // optional .GroupKey newGroupKey = 5; bool has_newgroupkey() const; void clear_newgroupkey() ; const ::GroupKey& newgroupkey() const; - PROTOBUF_NODISCARD ::GroupKey* release_newgroupkey(); - ::GroupKey* mutable_newgroupkey(); - void set_allocated_newgroupkey(::GroupKey* value); - void unsafe_arena_set_allocated_newgroupkey(::GroupKey* value); - ::GroupKey* unsafe_arena_release_newgroupkey(); + [[nodiscard]] ::GroupKey* PROTOBUF_NULLABLE release_newgroupkey(); + ::GroupKey* PROTOBUF_NONNULL mutable_newgroupkey(); + void set_allocated_newgroupkey(::GroupKey* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_newgroupkey(::GroupKey* PROTOBUF_NULLABLE value); + ::GroupKey* PROTOBUF_NULLABLE unsafe_arena_release_newgroupkey(); private: const ::GroupKey& _internal_newgroupkey() const; - ::GroupKey* _internal_mutable_newgroupkey(); + ::GroupKey* PROTOBUF_NONNULL _internal_mutable_newgroupkey(); public: // .ContentType contentType = 2; @@ -2860,6 +2911,11 @@ class ContentMessage final : // @@protoc_insertion_point(class_scope:ContentMessage) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 1, 33, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -2868,52 +2924,56 @@ class ContentMessage final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ContentMessage& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr content_; ::google::protobuf::internal::ArenaStringPtr groupkeyid_; - ::GroupKey* newgroupkey_; + ::GroupKey* PROTOBUF_NULLABLE newgroupkey_; int contenttype_; int encryptiontype_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ContentMessage_class_data_; +// ------------------------------------------------------------------- -class StreamPartitionInfo final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:StreamPartitionInfo) */ { +class StreamPartitionInfo final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:StreamPartitionInfo) */ { public: inline StreamPartitionInfo() : StreamPartitionInfo(nullptr) {} - ~StreamPartitionInfo() override; - template - explicit PROTOBUF_CONSTEXPR StreamPartitionInfo(::google::protobuf::internal::ConstantInitialized); + ~StreamPartitionInfo() PROTOBUF_FINAL; - inline StreamPartitionInfo(const StreamPartitionInfo& from) - : StreamPartitionInfo(nullptr, from) {} - StreamPartitionInfo(StreamPartitionInfo&& from) noexcept - : StreamPartitionInfo() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StreamPartitionInfo* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StreamPartitionInfo)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR StreamPartitionInfo(::google::protobuf::internal::ConstantInitialized); + inline StreamPartitionInfo(const StreamPartitionInfo& from) : StreamPartitionInfo(nullptr, from) {} + inline StreamPartitionInfo(StreamPartitionInfo&& from) noexcept + : StreamPartitionInfo(nullptr, ::std::move(from)) {} inline StreamPartitionInfo& operator=(const StreamPartitionInfo& from) { CopyFrom(from); return *this; } inline StreamPartitionInfo& operator=(StreamPartitionInfo&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -2925,47 +2985,35 @@ class StreamPartitionInfo final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StreamPartitionInfo& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_StreamPartitionInfo_default_instance_); } - static inline const StreamPartitionInfo* internal_default_instance() { - return reinterpret_cast( - &_StreamPartitionInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(StreamPartitionInfo& a, StreamPartitionInfo& b) { - a.Swap(&b); - } - inline void Swap(StreamPartitionInfo* other) { + static constexpr int kIndexInFileMessages = 18; + friend void swap(StreamPartitionInfo& a, StreamPartitionInfo& b) { a.Swap(&b); } + inline void Swap(StreamPartitionInfo* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StreamPartitionInfo* other) { + void UnsafeArenaSwap(StreamPartitionInfo* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -2973,33 +3021,40 @@ class StreamPartitionInfo final : // implements Message ---------------------------------------------- - StreamPartitionInfo* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StreamPartitionInfo* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(StreamPartitionInfo* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "StreamPartitionInfo"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(StreamPartitionInfo* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "StreamPartitionInfo"; } + + explicit StreamPartitionInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StreamPartitionInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamPartitionInfo& from); + StreamPartitionInfo( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StreamPartitionInfo&& from) noexcept + : StreamPartitionInfo(arena) { + *this = ::std::move(from); } - protected: - explicit StreamPartitionInfo(::google::protobuf::Arena* arena); - StreamPartitionInfo(::google::protobuf::Arena* arena, const StreamPartitionInfo& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kControlLayerNeighborsFieldNumber = 2, kContentDeliveryLayerNeighborsFieldNumber = 3, @@ -3012,17 +3067,16 @@ class StreamPartitionInfo final : public: void clear_controllayerneighbors() ; - ::dht::PeerDescriptor* mutable_controllayerneighbors(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_controllayerneighbors(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_controllayerneighbors(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_controllayerneighbors(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_controllayerneighbors() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_controllayerneighbors(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_controllayerneighbors(); public: const ::dht::PeerDescriptor& controllayerneighbors(int index) const; - ::dht::PeerDescriptor* add_controllayerneighbors(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - controllayerneighbors() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_controllayerneighbors(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& controllayerneighbors() const; // repeated .dht.PeerDescriptor contentDeliveryLayerNeighbors = 3; int contentdeliverylayerneighbors_size() const; private: @@ -3030,36 +3084,39 @@ class StreamPartitionInfo final : public: void clear_contentdeliverylayerneighbors() ; - ::dht::PeerDescriptor* mutable_contentdeliverylayerneighbors(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_contentdeliverylayerneighbors(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_contentdeliverylayerneighbors(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_contentdeliverylayerneighbors(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_contentdeliverylayerneighbors() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_contentdeliverylayerneighbors(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_contentdeliverylayerneighbors(); public: const ::dht::PeerDescriptor& contentdeliverylayerneighbors(int index) const; - ::dht::PeerDescriptor* add_contentdeliverylayerneighbors(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - contentdeliverylayerneighbors() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_contentdeliverylayerneighbors(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& contentdeliverylayerneighbors() const; // string id = 1; void clear_id() ; - const std::string& id() const; - template + const ::std::string& id() const; + template void set_id(Arg_&& arg, Args_... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_id(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_id(); + void set_allocated_id(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id( - const std::string& value); - std::string* _internal_mutable_id(); + const ::std::string& _internal_id() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_id(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_id(); public: // @@protoc_insertion_point(class_scope:StreamPartitionInfo) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 30, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3068,49 +3125,54 @@ class StreamPartitionInfo final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const StreamPartitionInfo& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > controllayerneighbors_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > contentdeliverylayerneighbors_; ::google::protobuf::internal::ArenaStringPtr id_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StreamPartitionInfo_class_data_; +// ------------------------------------------------------------------- -class StreamPartHandshakeResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:StreamPartHandshakeResponse) */ { +class StreamPartHandshakeResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:StreamPartHandshakeResponse) */ { public: inline StreamPartHandshakeResponse() : StreamPartHandshakeResponse(nullptr) {} - ~StreamPartHandshakeResponse() override; - template - explicit PROTOBUF_CONSTEXPR StreamPartHandshakeResponse(::google::protobuf::internal::ConstantInitialized); + ~StreamPartHandshakeResponse() PROTOBUF_FINAL; - inline StreamPartHandshakeResponse(const StreamPartHandshakeResponse& from) - : StreamPartHandshakeResponse(nullptr, from) {} - StreamPartHandshakeResponse(StreamPartHandshakeResponse&& from) noexcept - : StreamPartHandshakeResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StreamPartHandshakeResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StreamPartHandshakeResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR StreamPartHandshakeResponse(::google::protobuf::internal::ConstantInitialized); + inline StreamPartHandshakeResponse(const StreamPartHandshakeResponse& from) : StreamPartHandshakeResponse(nullptr, from) {} + inline StreamPartHandshakeResponse(StreamPartHandshakeResponse&& from) noexcept + : StreamPartHandshakeResponse(nullptr, ::std::move(from)) {} inline StreamPartHandshakeResponse& operator=(const StreamPartHandshakeResponse& from) { CopyFrom(from); return *this; } inline StreamPartHandshakeResponse& operator=(StreamPartHandshakeResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3122,47 +3184,35 @@ class StreamPartHandshakeResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StreamPartHandshakeResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_StreamPartHandshakeResponse_default_instance_); } - static inline const StreamPartHandshakeResponse* internal_default_instance() { - return reinterpret_cast( - &_StreamPartHandshakeResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(StreamPartHandshakeResponse& a, StreamPartHandshakeResponse& b) { - a.Swap(&b); - } - inline void Swap(StreamPartHandshakeResponse* other) { + static constexpr int kIndexInFileMessages = 8; + friend void swap(StreamPartHandshakeResponse& a, StreamPartHandshakeResponse& b) { a.Swap(&b); } + inline void Swap(StreamPartHandshakeResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StreamPartHandshakeResponse* other) { + void UnsafeArenaSwap(StreamPartHandshakeResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3170,33 +3220,40 @@ class StreamPartHandshakeResponse final : // implements Message ---------------------------------------------- - StreamPartHandshakeResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StreamPartHandshakeResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(StreamPartHandshakeResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "StreamPartHandshakeResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(StreamPartHandshakeResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "StreamPartHandshakeResponse"; } + + explicit StreamPartHandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StreamPartHandshakeResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamPartHandshakeResponse& from); + StreamPartHandshakeResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StreamPartHandshakeResponse&& from) noexcept + : StreamPartHandshakeResponse(arena) { + *this = ::std::move(from); } - protected: - explicit StreamPartHandshakeResponse(::google::protobuf::Arena* arena); - StreamPartHandshakeResponse(::google::protobuf::Arena* arena, const StreamPartHandshakeResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kRequestIdFieldNumber = 2, kInterleaveTargetDescriptorFieldNumber = 3, @@ -3204,33 +3261,32 @@ class StreamPartHandshakeResponse final : }; // string requestId = 2; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional .dht.PeerDescriptor interleaveTargetDescriptor = 3; bool has_interleavetargetdescriptor() const; void clear_interleavetargetdescriptor() ; const ::dht::PeerDescriptor& interleavetargetdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_interleavetargetdescriptor(); - ::dht::PeerDescriptor* mutable_interleavetargetdescriptor(); - void set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_interleavetargetdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_interleavetargetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_interleavetargetdescriptor(); + void set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_interleavetargetdescriptor(); private: const ::dht::PeerDescriptor& _internal_interleavetargetdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_interleavetargetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_interleavetargetdescriptor(); public: // bool accepted = 1; @@ -3246,6 +3302,11 @@ class StreamPartHandshakeResponse final : // @@protoc_insertion_point(class_scope:StreamPartHandshakeResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 1, 45, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3254,50 +3315,54 @@ class StreamPartHandshakeResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const StreamPartHandshakeResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; - ::dht::PeerDescriptor* interleavetargetdescriptor_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE interleavetargetdescriptor_; bool accepted_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class StreamMessage final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:StreamMessage) */ { +extern const ::google::protobuf::internal::ClassDataFull StreamPartHandshakeResponse_class_data_; +// ------------------------------------------------------------------- + +class StreamMessage final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:StreamMessage) */ { public: inline StreamMessage() : StreamMessage(nullptr) {} - ~StreamMessage() override; - template - explicit PROTOBUF_CONSTEXPR StreamMessage(::google::protobuf::internal::ConstantInitialized); + ~StreamMessage() PROTOBUF_FINAL; - inline StreamMessage(const StreamMessage& from) - : StreamMessage(nullptr, from) {} - StreamMessage(StreamMessage&& from) noexcept - : StreamMessage() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StreamMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StreamMessage)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR StreamMessage(::google::protobuf::internal::ConstantInitialized); + inline StreamMessage(const StreamMessage& from) : StreamMessage(nullptr, from) {} + inline StreamMessage(StreamMessage&& from) noexcept + : StreamMessage(nullptr, ::std::move(from)) {} inline StreamMessage& operator=(const StreamMessage& from) { CopyFrom(from); return *this; } inline StreamMessage& operator=(StreamMessage&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3309,22 +3374,23 @@ class StreamMessage final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const StreamMessage& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_StreamMessage_default_instance_); } enum BodyCase { kContentMessage = 5, @@ -3332,31 +3398,17 @@ class StreamMessage final : kGroupKeyResponse = 7, BODY_NOT_SET = 0, }; - - static inline const StreamMessage* internal_default_instance() { - return reinterpret_cast( - &_StreamMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(StreamMessage& a, StreamMessage& b) { - a.Swap(&b); - } - inline void Swap(StreamMessage* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(StreamMessage& a, StreamMessage& b) { a.Swap(&b); } + inline void Swap(StreamMessage* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(StreamMessage* other) { + void UnsafeArenaSwap(StreamMessage* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3364,33 +3416,40 @@ class StreamMessage final : // implements Message ---------------------------------------------- - StreamMessage* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + StreamMessage* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(StreamMessage* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "StreamMessage"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(StreamMessage* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "StreamMessage"; } + + explicit StreamMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + StreamMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StreamMessage& from); + StreamMessage( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StreamMessage&& from) noexcept + : StreamMessage(arena) { + *this = ::std::move(from); } - protected: - explicit StreamMessage(::google::protobuf::Arena* arena); - StreamMessage(::google::protobuf::Arena* arena, const StreamMessage& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kSignatureFieldNumber = 3, kMessageIdFieldNumber = 1, @@ -3402,48 +3461,47 @@ class StreamMessage final : }; // bytes signature = 3; void clear_signature() ; - const std::string& signature() const; - template + const ::std::string& signature() const; + template void set_signature(Arg_&& arg, Args_... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_signature(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_signature(); + void set_allocated_signature(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature( - const std::string& value); - std::string* _internal_mutable_signature(); + const ::std::string& _internal_signature() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_signature(); public: // .MessageID messageId = 1; bool has_messageid() const; void clear_messageid() ; const ::MessageID& messageid() const; - PROTOBUF_NODISCARD ::MessageID* release_messageid(); - ::MessageID* mutable_messageid(); - void set_allocated_messageid(::MessageID* value); - void unsafe_arena_set_allocated_messageid(::MessageID* value); - ::MessageID* unsafe_arena_release_messageid(); + [[nodiscard]] ::MessageID* PROTOBUF_NULLABLE release_messageid(); + ::MessageID* PROTOBUF_NONNULL mutable_messageid(); + void set_allocated_messageid(::MessageID* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_messageid(::MessageID* PROTOBUF_NULLABLE value); + ::MessageID* PROTOBUF_NULLABLE unsafe_arena_release_messageid(); private: const ::MessageID& _internal_messageid() const; - ::MessageID* _internal_mutable_messageid(); + ::MessageID* PROTOBUF_NONNULL _internal_mutable_messageid(); public: // optional .MessageRef previousMessageRef = 2; bool has_previousmessageref() const; void clear_previousmessageref() ; const ::MessageRef& previousmessageref() const; - PROTOBUF_NODISCARD ::MessageRef* release_previousmessageref(); - ::MessageRef* mutable_previousmessageref(); - void set_allocated_previousmessageref(::MessageRef* value); - void unsafe_arena_set_allocated_previousmessageref(::MessageRef* value); - ::MessageRef* unsafe_arena_release_previousmessageref(); + [[nodiscard]] ::MessageRef* PROTOBUF_NULLABLE release_previousmessageref(); + ::MessageRef* PROTOBUF_NONNULL mutable_previousmessageref(); + void set_allocated_previousmessageref(::MessageRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_previousmessageref(::MessageRef* PROTOBUF_NULLABLE value); + ::MessageRef* PROTOBUF_NULLABLE unsafe_arena_release_previousmessageref(); private: const ::MessageRef& _internal_previousmessageref() const; - ::MessageRef* _internal_mutable_previousmessageref(); + ::MessageRef* PROTOBUF_NONNULL _internal_mutable_previousmessageref(); public: // .SignatureType signatureType = 4; @@ -3464,15 +3522,15 @@ class StreamMessage final : public: void clear_contentmessage() ; const ::ContentMessage& contentmessage() const; - PROTOBUF_NODISCARD ::ContentMessage* release_contentmessage(); - ::ContentMessage* mutable_contentmessage(); - void set_allocated_contentmessage(::ContentMessage* value); - void unsafe_arena_set_allocated_contentmessage(::ContentMessage* value); - ::ContentMessage* unsafe_arena_release_contentmessage(); + [[nodiscard]] ::ContentMessage* PROTOBUF_NULLABLE release_contentmessage(); + ::ContentMessage* PROTOBUF_NONNULL mutable_contentmessage(); + void set_allocated_contentmessage(::ContentMessage* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_contentmessage(::ContentMessage* PROTOBUF_NULLABLE value); + ::ContentMessage* PROTOBUF_NULLABLE unsafe_arena_release_contentmessage(); private: const ::ContentMessage& _internal_contentmessage() const; - ::ContentMessage* _internal_mutable_contentmessage(); + ::ContentMessage* PROTOBUF_NONNULL _internal_mutable_contentmessage(); public: // .GroupKeyRequest groupKeyRequest = 6; @@ -3483,15 +3541,15 @@ class StreamMessage final : public: void clear_groupkeyrequest() ; const ::GroupKeyRequest& groupkeyrequest() const; - PROTOBUF_NODISCARD ::GroupKeyRequest* release_groupkeyrequest(); - ::GroupKeyRequest* mutable_groupkeyrequest(); - void set_allocated_groupkeyrequest(::GroupKeyRequest* value); - void unsafe_arena_set_allocated_groupkeyrequest(::GroupKeyRequest* value); - ::GroupKeyRequest* unsafe_arena_release_groupkeyrequest(); + [[nodiscard]] ::GroupKeyRequest* PROTOBUF_NULLABLE release_groupkeyrequest(); + ::GroupKeyRequest* PROTOBUF_NONNULL mutable_groupkeyrequest(); + void set_allocated_groupkeyrequest(::GroupKeyRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_groupkeyrequest(::GroupKeyRequest* PROTOBUF_NULLABLE value); + ::GroupKeyRequest* PROTOBUF_NULLABLE unsafe_arena_release_groupkeyrequest(); private: const ::GroupKeyRequest& _internal_groupkeyrequest() const; - ::GroupKeyRequest* _internal_mutable_groupkeyrequest(); + ::GroupKeyRequest* PROTOBUF_NONNULL _internal_mutable_groupkeyrequest(); public: // .GroupKeyResponse groupKeyResponse = 7; @@ -3502,15 +3560,15 @@ class StreamMessage final : public: void clear_groupkeyresponse() ; const ::GroupKeyResponse& groupkeyresponse() const; - PROTOBUF_NODISCARD ::GroupKeyResponse* release_groupkeyresponse(); - ::GroupKeyResponse* mutable_groupkeyresponse(); - void set_allocated_groupkeyresponse(::GroupKeyResponse* value); - void unsafe_arena_set_allocated_groupkeyresponse(::GroupKeyResponse* value); - ::GroupKeyResponse* unsafe_arena_release_groupkeyresponse(); + [[nodiscard]] ::GroupKeyResponse* PROTOBUF_NULLABLE release_groupkeyresponse(); + ::GroupKeyResponse* PROTOBUF_NONNULL mutable_groupkeyresponse(); + void set_allocated_groupkeyresponse(::GroupKeyResponse* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_groupkeyresponse(::GroupKeyResponse* PROTOBUF_NULLABLE value); + ::GroupKeyResponse* PROTOBUF_NULLABLE unsafe_arena_release_groupkeyresponse(); private: const ::GroupKeyResponse& _internal_groupkeyresponse() const; - ::GroupKeyResponse* _internal_mutable_groupkeyresponse(); + ::GroupKeyResponse* PROTOBUF_NONNULL _internal_mutable_groupkeyresponse(); public: void clear_body(); @@ -3521,9 +3579,13 @@ class StreamMessage final : void set_has_contentmessage(); void set_has_groupkeyrequest(); void set_has_groupkeyresponse(); - inline bool has_body() const; inline void clear_has_body(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 7, + 5, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3532,60 +3594,63 @@ class StreamMessage final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const StreamMessage& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr signature_; - ::MessageID* messageid_; - ::MessageRef* previousmessageref_; + ::MessageID* PROTOBUF_NULLABLE messageid_; + ::MessageRef* PROTOBUF_NULLABLE previousmessageref_; int signaturetype_; union BodyUnion { constexpr BodyUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::ContentMessage* contentmessage_; - ::GroupKeyRequest* groupkeyrequest_; - ::GroupKeyResponse* groupkeyresponse_; + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE contentmessage_; + ::google::protobuf::Message* PROTOBUF_NULLABLE groupkeyrequest_; + ::google::protobuf::Message* PROTOBUF_NULLABLE groupkeyresponse_; } body_; ::uint32_t _oneof_case_[1]; - PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull StreamMessage_class_data_; +// ------------------------------------------------------------------- -class NeighborUpdate final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:NeighborUpdate) */ { +class NeighborUpdate final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:NeighborUpdate) */ { public: inline NeighborUpdate() : NeighborUpdate(nullptr) {} - ~NeighborUpdate() override; - template - explicit PROTOBUF_CONSTEXPR NeighborUpdate(::google::protobuf::internal::ConstantInitialized); + ~NeighborUpdate() PROTOBUF_FINAL; - inline NeighborUpdate(const NeighborUpdate& from) - : NeighborUpdate(nullptr, from) {} - NeighborUpdate(NeighborUpdate&& from) noexcept - : NeighborUpdate() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(NeighborUpdate* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(NeighborUpdate)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR NeighborUpdate(::google::protobuf::internal::ConstantInitialized); + inline NeighborUpdate(const NeighborUpdate& from) : NeighborUpdate(nullptr, from) {} + inline NeighborUpdate(NeighborUpdate&& from) noexcept + : NeighborUpdate(nullptr, ::std::move(from)) {} inline NeighborUpdate& operator=(const NeighborUpdate& from) { CopyFrom(from); return *this; } inline NeighborUpdate& operator=(NeighborUpdate&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3597,47 +3662,35 @@ class NeighborUpdate final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const NeighborUpdate& default_instance() { - return *internal_default_instance(); - } - static inline const NeighborUpdate* internal_default_instance() { - return reinterpret_cast( - &_NeighborUpdate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(NeighborUpdate& a, NeighborUpdate& b) { - a.Swap(&b); + return *reinterpret_cast( + &_NeighborUpdate_default_instance_); } - inline void Swap(NeighborUpdate* other) { + static constexpr int kIndexInFileMessages = 12; + friend void swap(NeighborUpdate& a, NeighborUpdate& b) { a.Swap(&b); } + inline void Swap(NeighborUpdate* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(NeighborUpdate* other) { + void UnsafeArenaSwap(NeighborUpdate* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3645,33 +3698,40 @@ class NeighborUpdate final : // implements Message ---------------------------------------------- - NeighborUpdate* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + NeighborUpdate* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(NeighborUpdate* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "NeighborUpdate"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(NeighborUpdate* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "NeighborUpdate"; } + + explicit NeighborUpdate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + NeighborUpdate(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NeighborUpdate& from); + NeighborUpdate( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NeighborUpdate&& from) noexcept + : NeighborUpdate(arena) { + *this = ::std::move(from); } - protected: - explicit NeighborUpdate(::google::protobuf::Arena* arena); - NeighborUpdate(::google::protobuf::Arena* arena, const NeighborUpdate& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNeighborDescriptorsFieldNumber = 3, kStreamPartIdFieldNumber = 1, @@ -3684,31 +3744,29 @@ class NeighborUpdate final : public: void clear_neighbordescriptors() ; - ::dht::PeerDescriptor* mutable_neighbordescriptors(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_neighbordescriptors(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_neighbordescriptors(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_neighbordescriptors(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_neighbordescriptors() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_neighbordescriptors(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_neighbordescriptors(); public: const ::dht::PeerDescriptor& neighbordescriptors(int index) const; - ::dht::PeerDescriptor* add_neighbordescriptors(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - neighbordescriptors() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_neighbordescriptors(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& neighbordescriptors() const; // string streamPartId = 1; void clear_streampartid() ; - const std::string& streampartid() const; - template + const ::std::string& streampartid() const; + template void set_streampartid(Arg_&& arg, Args_... args); - std::string* mutable_streampartid(); - PROTOBUF_NODISCARD std::string* release_streampartid(); - void set_allocated_streampartid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_streampartid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_streampartid(); + void set_allocated_streampartid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_streampartid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_streampartid( - const std::string& value); - std::string* _internal_mutable_streampartid(); + const ::std::string& _internal_streampartid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_streampartid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_streampartid(); public: // bool removeMe = 2; @@ -3724,6 +3782,11 @@ class NeighborUpdate final : // @@protoc_insertion_point(class_scope:NeighborUpdate) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 1, 35, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -3732,49 +3795,54 @@ class NeighborUpdate final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const NeighborUpdate& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > neighbordescriptors_; ::google::protobuf::internal::ArenaStringPtr streampartid_; bool removeme_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; -class InterleaveRequest final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:InterleaveRequest) */ { +extern const ::google::protobuf::internal::ClassDataFull NeighborUpdate_class_data_; +// ------------------------------------------------------------------- + +class InterleaveRequest final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:InterleaveRequest) */ { public: inline InterleaveRequest() : InterleaveRequest(nullptr) {} - ~InterleaveRequest() override; - template - explicit PROTOBUF_CONSTEXPR InterleaveRequest(::google::protobuf::internal::ConstantInitialized); + ~InterleaveRequest() PROTOBUF_FINAL; - inline InterleaveRequest(const InterleaveRequest& from) - : InterleaveRequest(nullptr, from) {} - InterleaveRequest(InterleaveRequest&& from) noexcept - : InterleaveRequest() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(InterleaveRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(InterleaveRequest)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR InterleaveRequest(::google::protobuf::internal::ConstantInitialized); + inline InterleaveRequest(const InterleaveRequest& from) : InterleaveRequest(nullptr, from) {} + inline InterleaveRequest(InterleaveRequest&& from) noexcept + : InterleaveRequest(nullptr, ::std::move(from)) {} inline InterleaveRequest& operator=(const InterleaveRequest& from) { CopyFrom(from); return *this; } inline InterleaveRequest& operator=(InterleaveRequest&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3786,47 +3854,35 @@ class InterleaveRequest final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const InterleaveRequest& default_instance() { - return *internal_default_instance(); - } - static inline const InterleaveRequest* internal_default_instance() { - return reinterpret_cast( - &_InterleaveRequest_default_instance_); + return *reinterpret_cast( + &_InterleaveRequest_default_instance_); } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(InterleaveRequest& a, InterleaveRequest& b) { - a.Swap(&b); - } - inline void Swap(InterleaveRequest* other) { + static constexpr int kIndexInFileMessages = 9; + friend void swap(InterleaveRequest& a, InterleaveRequest& b) { a.Swap(&b); } + inline void Swap(InterleaveRequest* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(InterleaveRequest* other) { + void UnsafeArenaSwap(InterleaveRequest* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3834,33 +3890,40 @@ class InterleaveRequest final : // implements Message ---------------------------------------------- - InterleaveRequest* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + InterleaveRequest* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(InterleaveRequest* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "InterleaveRequest"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(InterleaveRequest* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "InterleaveRequest"; } + + explicit InterleaveRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + InterleaveRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const InterleaveRequest& from); + InterleaveRequest( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, InterleaveRequest&& from) noexcept + : InterleaveRequest(arena) { + *this = ::std::move(from); } - protected: - explicit InterleaveRequest(::google::protobuf::Arena* arena); - InterleaveRequest(::google::protobuf::Arena* arena, const InterleaveRequest& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kInterleaveTargetDescriptorFieldNumber = 1, }; @@ -3868,20 +3931,25 @@ class InterleaveRequest final : bool has_interleavetargetdescriptor() const; void clear_interleavetargetdescriptor() ; const ::dht::PeerDescriptor& interleavetargetdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_interleavetargetdescriptor(); - ::dht::PeerDescriptor* mutable_interleavetargetdescriptor(); - void set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_interleavetargetdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_interleavetargetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_interleavetargetdescriptor(); + void set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_interleavetargetdescriptor(); private: const ::dht::PeerDescriptor& _internal_interleavetargetdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_interleavetargetdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_interleavetargetdescriptor(); public: // @@protoc_insertion_point(class_scope:InterleaveRequest) 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; @@ -3890,48 +3958,52 @@ class InterleaveRequest final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const InterleaveRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::dht::PeerDescriptor* interleavetargetdescriptor_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE interleavetargetdescriptor_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull InterleaveRequest_class_data_; +// ------------------------------------------------------------------- -class ControlLayerInfo final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ControlLayerInfo) */ { +class ControlLayerInfo final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:ControlLayerInfo) */ { public: inline ControlLayerInfo() : ControlLayerInfo(nullptr) {} - ~ControlLayerInfo() override; - template - explicit PROTOBUF_CONSTEXPR ControlLayerInfo(::google::protobuf::internal::ConstantInitialized); + ~ControlLayerInfo() PROTOBUF_FINAL; - inline ControlLayerInfo(const ControlLayerInfo& from) - : ControlLayerInfo(nullptr, from) {} - ControlLayerInfo(ControlLayerInfo&& from) noexcept - : ControlLayerInfo() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ControlLayerInfo* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ControlLayerInfo)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR ControlLayerInfo(::google::protobuf::internal::ConstantInitialized); + inline ControlLayerInfo(const ControlLayerInfo& from) : ControlLayerInfo(nullptr, from) {} + inline ControlLayerInfo(ControlLayerInfo&& from) noexcept + : ControlLayerInfo(nullptr, ::std::move(from)) {} inline ControlLayerInfo& operator=(const ControlLayerInfo& from) { CopyFrom(from); return *this; } inline ControlLayerInfo& operator=(ControlLayerInfo&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -3943,47 +4015,35 @@ class ControlLayerInfo final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const ControlLayerInfo& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_ControlLayerInfo_default_instance_); } - static inline const ControlLayerInfo* internal_default_instance() { - return reinterpret_cast( - &_ControlLayerInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(ControlLayerInfo& a, ControlLayerInfo& b) { - a.Swap(&b); - } - inline void Swap(ControlLayerInfo* other) { + static constexpr int kIndexInFileMessages = 19; + friend void swap(ControlLayerInfo& a, ControlLayerInfo& b) { a.Swap(&b); } + inline void Swap(ControlLayerInfo* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ControlLayerInfo* other) { + void UnsafeArenaSwap(ControlLayerInfo* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3991,33 +4051,40 @@ class ControlLayerInfo final : // implements Message ---------------------------------------------- - ControlLayerInfo* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + ControlLayerInfo* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(ControlLayerInfo* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "ControlLayerInfo"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ControlLayerInfo* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "ControlLayerInfo"; } + + explicit ControlLayerInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ControlLayerInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ControlLayerInfo& from); + ControlLayerInfo( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ControlLayerInfo&& from) noexcept + : ControlLayerInfo(arena) { + *this = ::std::move(from); } - protected: - explicit ControlLayerInfo(::google::protobuf::Arena* arena); - ControlLayerInfo(::google::protobuf::Arena* arena, const ControlLayerInfo& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kNeighborsFieldNumber = 1, kConnectionsFieldNumber = 2, @@ -4029,17 +4096,16 @@ class ControlLayerInfo final : public: void clear_neighbors() ; - ::dht::PeerDescriptor* mutable_neighbors(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_neighbors(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_neighbors(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_neighbors(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_neighbors() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_neighbors(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_neighbors(); public: const ::dht::PeerDescriptor& neighbors(int index) const; - ::dht::PeerDescriptor* add_neighbors(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - neighbors() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_neighbors(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& neighbors() const; // repeated .dht.PeerDescriptor connections = 2; int connections_size() const; private: @@ -4047,20 +4113,24 @@ class ControlLayerInfo final : public: void clear_connections() ; - ::dht::PeerDescriptor* mutable_connections(int index); - ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >* - mutable_connections(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_connections(int index); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL mutable_connections(); + private: const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& _internal_connections() const; - ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* _internal_mutable_connections(); + ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL _internal_mutable_connections(); public: const ::dht::PeerDescriptor& connections(int index) const; - ::dht::PeerDescriptor* add_connections(); - const ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor >& - connections() const; + ::dht::PeerDescriptor* PROTOBUF_NONNULL add_connections(); + const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& connections() const; // @@protoc_insertion_point(class_scope:ControlLayerInfo) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 2, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4069,48 +4139,53 @@ class ControlLayerInfo final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ControlLayerInfo& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > neighbors_; ::google::protobuf::RepeatedPtrField< ::dht::PeerDescriptor > connections_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull ControlLayerInfo_class_data_; +// ------------------------------------------------------------------- -class NodeInfoResponse final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:NodeInfoResponse) */ { +class NodeInfoResponse final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:NodeInfoResponse) */ { public: inline NodeInfoResponse() : NodeInfoResponse(nullptr) {} - ~NodeInfoResponse() override; - template - explicit PROTOBUF_CONSTEXPR NodeInfoResponse(::google::protobuf::internal::ConstantInitialized); + ~NodeInfoResponse() PROTOBUF_FINAL; - inline NodeInfoResponse(const NodeInfoResponse& from) - : NodeInfoResponse(nullptr, from) {} - NodeInfoResponse(NodeInfoResponse&& from) noexcept - : NodeInfoResponse() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(NodeInfoResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(NodeInfoResponse)); } +#endif + + template + explicit PROTOBUF_CONSTEXPR NodeInfoResponse(::google::protobuf::internal::ConstantInitialized); + inline NodeInfoResponse(const NodeInfoResponse& from) : NodeInfoResponse(nullptr, from) {} + inline NodeInfoResponse(NodeInfoResponse&& from) noexcept + : NodeInfoResponse(nullptr, ::std::move(from)) {} inline NodeInfoResponse& operator=(const NodeInfoResponse& from) { CopyFrom(from); return *this; } inline NodeInfoResponse& operator=(NodeInfoResponse&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -4122,47 +4197,35 @@ class NodeInfoResponse final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const NodeInfoResponse& default_instance() { - return *internal_default_instance(); + return *reinterpret_cast( + &_NodeInfoResponse_default_instance_); } - static inline const NodeInfoResponse* internal_default_instance() { - return reinterpret_cast( - &_NodeInfoResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(NodeInfoResponse& a, NodeInfoResponse& b) { - a.Swap(&b); - } - inline void Swap(NodeInfoResponse* other) { + static constexpr int kIndexInFileMessages = 21; + friend void swap(NodeInfoResponse& a, NodeInfoResponse& b) { a.Swap(&b); } + inline void Swap(NodeInfoResponse* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(NodeInfoResponse* other) { + void UnsafeArenaSwap(NodeInfoResponse* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4170,33 +4233,40 @@ class NodeInfoResponse final : // implements Message ---------------------------------------------- - NodeInfoResponse* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + NodeInfoResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(NodeInfoResponse* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "NodeInfoResponse"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(NodeInfoResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "NodeInfoResponse"; } + + explicit NodeInfoResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + NodeInfoResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NodeInfoResponse& from); + NodeInfoResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NodeInfoResponse&& from) noexcept + : NodeInfoResponse(arena) { + *this = ::std::move(from); } - protected: - explicit NodeInfoResponse(::google::protobuf::Arena* arena); - NodeInfoResponse(::google::protobuf::Arena* arena, const NodeInfoResponse& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kStreamPartitionsFieldNumber = 2, kVersionFieldNumber = 4, @@ -4210,66 +4280,69 @@ class NodeInfoResponse final : public: void clear_streampartitions() ; - ::StreamPartitionInfo* mutable_streampartitions(int index); - ::google::protobuf::RepeatedPtrField< ::StreamPartitionInfo >* - mutable_streampartitions(); + ::StreamPartitionInfo* PROTOBUF_NONNULL mutable_streampartitions(int index); + ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* PROTOBUF_NONNULL mutable_streampartitions(); + private: const ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>& _internal_streampartitions() const; - ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* _internal_mutable_streampartitions(); + ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* PROTOBUF_NONNULL _internal_mutable_streampartitions(); public: const ::StreamPartitionInfo& streampartitions(int index) const; - ::StreamPartitionInfo* add_streampartitions(); - const ::google::protobuf::RepeatedPtrField< ::StreamPartitionInfo >& - streampartitions() const; + ::StreamPartitionInfo* PROTOBUF_NONNULL add_streampartitions(); + const ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>& streampartitions() const; // string version = 4; void clear_version() ; - const std::string& version() const; - template + const ::std::string& version() const; + template void set_version(Arg_&& arg, Args_... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_version(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_version(); + void set_allocated_version(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version( - const std::string& value); - std::string* _internal_mutable_version(); + const ::std::string& _internal_version() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_version(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_version(); public: // .dht.PeerDescriptor peerDescriptor = 1; bool has_peerdescriptor() const; void clear_peerdescriptor() ; const ::dht::PeerDescriptor& peerdescriptor() const; - PROTOBUF_NODISCARD ::dht::PeerDescriptor* release_peerdescriptor(); - ::dht::PeerDescriptor* mutable_peerdescriptor(); - void set_allocated_peerdescriptor(::dht::PeerDescriptor* value); - void unsafe_arena_set_allocated_peerdescriptor(::dht::PeerDescriptor* value); - ::dht::PeerDescriptor* unsafe_arena_release_peerdescriptor(); + [[nodiscard]] ::dht::PeerDescriptor* PROTOBUF_NULLABLE release_peerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL mutable_peerdescriptor(); + void set_allocated_peerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_peerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value); + ::dht::PeerDescriptor* PROTOBUF_NULLABLE unsafe_arena_release_peerdescriptor(); private: const ::dht::PeerDescriptor& _internal_peerdescriptor() const; - ::dht::PeerDescriptor* _internal_mutable_peerdescriptor(); + ::dht::PeerDescriptor* PROTOBUF_NONNULL _internal_mutable_peerdescriptor(); public: // optional .ControlLayerInfo controlLayer = 3; bool has_controllayer() const; void clear_controllayer() ; const ::ControlLayerInfo& controllayer() const; - PROTOBUF_NODISCARD ::ControlLayerInfo* release_controllayer(); - ::ControlLayerInfo* mutable_controllayer(); - void set_allocated_controllayer(::ControlLayerInfo* value); - void unsafe_arena_set_allocated_controllayer(::ControlLayerInfo* value); - ::ControlLayerInfo* unsafe_arena_release_controllayer(); + [[nodiscard]] ::ControlLayerInfo* PROTOBUF_NULLABLE release_controllayer(); + ::ControlLayerInfo* PROTOBUF_NONNULL mutable_controllayer(); + void set_allocated_controllayer(::ControlLayerInfo* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_controllayer(::ControlLayerInfo* PROTOBUF_NULLABLE value); + ::ControlLayerInfo* PROTOBUF_NULLABLE unsafe_arena_release_controllayer(); private: const ::ControlLayerInfo& _internal_controllayer() const; - ::ControlLayerInfo* _internal_mutable_controllayer(); + ::ControlLayerInfo* PROTOBUF_NONNULL _internal_mutable_controllayer(); public: // @@protoc_insertion_point(class_scope:NodeInfoResponse) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 4, + 3, 32, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4278,25 +4351,28 @@ class NodeInfoResponse final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const NodeInfoResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::StreamPartitionInfo > streampartitions_; ::google::protobuf::internal::ArenaStringPtr version_; - ::dht::PeerDescriptor* peerdescriptor_; - ::ControlLayerInfo* controllayer_; + ::dht::PeerDescriptor* PROTOBUF_NULLABLE peerdescriptor_; + ::ControlLayerInfo* PROTOBUF_NULLABLE controllayer_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull NodeInfoResponse_class_data_; + // =================================================================== @@ -4315,61 +4391,75 @@ class NodeInfoResponse final : // string streamId = 1; inline void MessageID::clear_streamid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streamid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& MessageID::streamid() const +inline const ::std::string& MessageID::streamid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:MessageID.streamId) return _internal_streamid(); } template -inline PROTOBUF_ALWAYS_INLINE void MessageID::set_streamid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void MessageID::set_streamid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.streamid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:MessageID.streamId) } -inline std::string* MessageID::mutable_streamid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_streamid(); +inline ::std::string* PROTOBUF_NONNULL MessageID::mutable_streamid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_streamid(); // @@protoc_insertion_point(field_mutable:MessageID.streamId) return _s; } -inline const std::string& MessageID::_internal_streamid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& MessageID::_internal_streamid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.streamid_.Get(); } -inline void MessageID::_internal_set_streamid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void MessageID::_internal_set_streamid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streamid_.Set(value, GetArena()); } -inline std::string* MessageID::_internal_mutable_streamid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL MessageID::_internal_mutable_streamid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.streamid_.Mutable( GetArena()); } -inline std::string* MessageID::release_streamid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE MessageID::release_streamid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:MessageID.streamId) - return _impl_.streamid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.streamid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.streamid_.Set("", GetArena()); + } + return released; } -inline void MessageID::set_allocated_streamid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void MessageID::set_allocated_streamid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.streamid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streamid_.IsDefault()) { - _impl_.streamid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.streamid_.IsDefault()) { + _impl_.streamid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:MessageID.streamId) } // int32 streamPartition = 2; inline void MessageID::clear_streampartition() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartition_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline ::int32_t MessageID::streampartition() const { // @@protoc_insertion_point(field_get:MessageID.streamPartition) @@ -4377,22 +4467,24 @@ inline ::int32_t MessageID::streampartition() const { } inline void MessageID::set_streampartition(::int32_t value) { _internal_set_streampartition(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:MessageID.streamPartition) } inline ::int32_t MessageID::_internal_streampartition() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.streampartition_; } inline void MessageID::_internal_set_streampartition(::int32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartition_ = value; } // int64 timestamp = 3; inline void MessageID::clear_timestamp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = ::int64_t{0}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline ::int64_t MessageID::timestamp() const { // @@protoc_insertion_point(field_get:MessageID.timestamp) @@ -4400,22 +4492,24 @@ inline ::int64_t MessageID::timestamp() const { } inline void MessageID::set_timestamp(::int64_t value) { _internal_set_timestamp(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:MessageID.timestamp) } inline ::int64_t MessageID::_internal_timestamp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timestamp_; } inline void MessageID::_internal_set_timestamp(::int64_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = value; } // int32 sequenceNumber = 4; inline void MessageID::clear_sequencenumber() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sequencenumber_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline ::int32_t MessageID::sequencenumber() const { // @@protoc_insertion_point(field_get:MessageID.sequenceNumber) @@ -4423,121 +4517,145 @@ inline ::int32_t MessageID::sequencenumber() const { } inline void MessageID::set_sequencenumber(::int32_t value) { _internal_set_sequencenumber(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:MessageID.sequenceNumber) } inline ::int32_t MessageID::_internal_sequencenumber() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.sequencenumber_; } inline void MessageID::_internal_set_sequencenumber(::int32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sequencenumber_ = value; } // bytes publisherId = 5; inline void MessageID::clear_publisherid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.publisherid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& MessageID::publisherid() const +inline const ::std::string& MessageID::publisherid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:MessageID.publisherId) return _internal_publisherid(); } template -inline PROTOBUF_ALWAYS_INLINE void MessageID::set_publisherid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void MessageID::set_publisherid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.publisherid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:MessageID.publisherId) } -inline std::string* MessageID::mutable_publisherid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_publisherid(); +inline ::std::string* PROTOBUF_NONNULL MessageID::mutable_publisherid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_publisherid(); // @@protoc_insertion_point(field_mutable:MessageID.publisherId) return _s; } -inline const std::string& MessageID::_internal_publisherid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& MessageID::_internal_publisherid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.publisherid_.Get(); } -inline void MessageID::_internal_set_publisherid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void MessageID::_internal_set_publisherid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.publisherid_.Set(value, GetArena()); } -inline std::string* MessageID::_internal_mutable_publisherid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL MessageID::_internal_mutable_publisherid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.publisherid_.Mutable( GetArena()); } -inline std::string* MessageID::release_publisherid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE MessageID::release_publisherid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:MessageID.publisherId) - return _impl_.publisherid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.publisherid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.publisherid_.Set("", GetArena()); + } + return released; } -inline void MessageID::set_allocated_publisherid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void MessageID::set_allocated_publisherid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.publisherid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publisherid_.IsDefault()) { - _impl_.publisherid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.publisherid_.IsDefault()) { + _impl_.publisherid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:MessageID.publisherId) } // string messageChainId = 6; inline void MessageID::clear_messagechainid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.messagechainid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& MessageID::messagechainid() const +inline const ::std::string& MessageID::messagechainid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:MessageID.messageChainId) return _internal_messagechainid(); } template -inline PROTOBUF_ALWAYS_INLINE void MessageID::set_messagechainid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void MessageID::set_messagechainid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.messagechainid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:MessageID.messageChainId) } -inline std::string* MessageID::mutable_messagechainid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_messagechainid(); +inline ::std::string* PROTOBUF_NONNULL MessageID::mutable_messagechainid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_messagechainid(); // @@protoc_insertion_point(field_mutable:MessageID.messageChainId) return _s; } -inline const std::string& MessageID::_internal_messagechainid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& MessageID::_internal_messagechainid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.messagechainid_.Get(); } -inline void MessageID::_internal_set_messagechainid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void MessageID::_internal_set_messagechainid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.messagechainid_.Set(value, GetArena()); } -inline std::string* MessageID::_internal_mutable_messagechainid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL MessageID::_internal_mutable_messagechainid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.messagechainid_.Mutable( GetArena()); } -inline std::string* MessageID::release_messagechainid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE MessageID::release_messagechainid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:MessageID.messageChainId) - return _impl_.messagechainid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.messagechainid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.messagechainid_.Set("", GetArena()); + } + return released; } -inline void MessageID::set_allocated_messagechainid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void MessageID::set_allocated_messagechainid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.messagechainid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagechainid_.IsDefault()) { - _impl_.messagechainid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.messagechainid_.IsDefault()) { + _impl_.messagechainid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:MessageID.messageChainId) } @@ -4547,8 +4665,10 @@ inline void MessageID::set_allocated_messagechainid(std::string* value) { // int64 timestamp = 1; inline void MessageRef::clear_timestamp() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = ::int64_t{0}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline ::int64_t MessageRef::timestamp() const { // @@protoc_insertion_point(field_get:MessageRef.timestamp) @@ -4556,22 +4676,24 @@ inline ::int64_t MessageRef::timestamp() const { } inline void MessageRef::set_timestamp(::int64_t value) { _internal_set_timestamp(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:MessageRef.timestamp) } inline ::int64_t MessageRef::_internal_timestamp() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timestamp_; } inline void MessageRef::_internal_set_timestamp(::int64_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = value; } // int32 sequenceNumber = 2; inline void MessageRef::clear_sequencenumber() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sequencenumber_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::int32_t MessageRef::sequencenumber() const { // @@protoc_insertion_point(field_get:MessageRef.sequenceNumber) @@ -4579,15 +4701,15 @@ inline ::int32_t MessageRef::sequencenumber() const { } inline void MessageRef::set_sequencenumber(::int32_t value) { _internal_set_sequencenumber(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:MessageRef.sequenceNumber) } inline ::int32_t MessageRef::_internal_sequencenumber() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.sequencenumber_; } inline void MessageRef::_internal_set_sequencenumber(::int32_t value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sequencenumber_ = value; } @@ -4597,17 +4719,18 @@ inline void MessageRef::_internal_set_sequencenumber(::int32_t value) { // .MessageID messageId = 1; inline bool StreamMessage::has_messageid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.messageid_ != nullptr); return value; } inline void StreamMessage::clear_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.messageid_ != nullptr) _impl_.messageid_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline const ::MessageID& StreamMessage::_internal_messageid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::MessageID* p = _impl_.messageid_; return p != nullptr ? *p : reinterpret_cast(::_MessageID_default_instance_); } @@ -4615,76 +4738,78 @@ inline const ::MessageID& StreamMessage::messageid() const ABSL_ATTRIBUTE_LIFETI // @@protoc_insertion_point(field_get:StreamMessage.messageId) return _internal_messageid(); } -inline void StreamMessage::unsafe_arena_set_allocated_messageid(::MessageID* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamMessage::unsafe_arena_set_allocated_messageid( + ::MessageID* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.messageid_); } _impl_.messageid_ = reinterpret_cast<::MessageID*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:StreamMessage.messageId) } -inline ::MessageID* StreamMessage::release_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::MessageID* PROTOBUF_NULLABLE StreamMessage::release_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::MessageID* released = _impl_.messageid_; _impl_.messageid_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::MessageID* StreamMessage::unsafe_arena_release_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::MessageID* PROTOBUF_NULLABLE StreamMessage::unsafe_arena_release_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamMessage.messageId) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::MessageID* temp = _impl_.messageid_; _impl_.messageid_ = nullptr; return temp; } -inline ::MessageID* StreamMessage::_internal_mutable_messageid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::MessageID* PROTOBUF_NONNULL StreamMessage::_internal_mutable_messageid() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.messageid_ == nullptr) { - auto* p = CreateMaybeMessage<::MessageID>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::MessageID>(GetArena()); _impl_.messageid_ = reinterpret_cast<::MessageID*>(p); } return _impl_.messageid_; } -inline ::MessageID* StreamMessage::mutable_messageid() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::MessageID* PROTOBUF_NONNULL StreamMessage::mutable_messageid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::MessageID* _msg = _internal_mutable_messageid(); // @@protoc_insertion_point(field_mutable:StreamMessage.messageId) return _msg; } -inline void StreamMessage::set_allocated_messageid(::MessageID* value) { +inline void StreamMessage::set_allocated_messageid(::MessageID* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::MessageID*>(_impl_.messageid_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.messageid_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::MessageID*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.messageid_ = reinterpret_cast<::MessageID*>(value); @@ -4693,17 +4818,18 @@ inline void StreamMessage::set_allocated_messageid(::MessageID* value) { // optional .MessageRef previousMessageRef = 2; inline bool StreamMessage::has_previousmessageref() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.previousmessageref_ != nullptr); return value; } inline void StreamMessage::clear_previousmessageref() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.previousmessageref_ != nullptr) _impl_.previousmessageref_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::MessageRef& StreamMessage::_internal_previousmessageref() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::MessageRef* p = _impl_.previousmessageref_; return p != nullptr ? *p : reinterpret_cast(::_MessageRef_default_instance_); } @@ -4711,76 +4837,78 @@ inline const ::MessageRef& StreamMessage::previousmessageref() const ABSL_ATTRIB // @@protoc_insertion_point(field_get:StreamMessage.previousMessageRef) return _internal_previousmessageref(); } -inline void StreamMessage::unsafe_arena_set_allocated_previousmessageref(::MessageRef* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamMessage::unsafe_arena_set_allocated_previousmessageref( + ::MessageRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.previousmessageref_); } _impl_.previousmessageref_ = reinterpret_cast<::MessageRef*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:StreamMessage.previousMessageRef) } -inline ::MessageRef* StreamMessage::release_previousmessageref() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::MessageRef* PROTOBUF_NULLABLE StreamMessage::release_previousmessageref() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::MessageRef* released = _impl_.previousmessageref_; _impl_.previousmessageref_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::MessageRef* StreamMessage::unsafe_arena_release_previousmessageref() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::MessageRef* PROTOBUF_NULLABLE StreamMessage::unsafe_arena_release_previousmessageref() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamMessage.previousMessageRef) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::MessageRef* temp = _impl_.previousmessageref_; _impl_.previousmessageref_ = nullptr; return temp; } -inline ::MessageRef* StreamMessage::_internal_mutable_previousmessageref() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::MessageRef* PROTOBUF_NONNULL StreamMessage::_internal_mutable_previousmessageref() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.previousmessageref_ == nullptr) { - auto* p = CreateMaybeMessage<::MessageRef>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::MessageRef>(GetArena()); _impl_.previousmessageref_ = reinterpret_cast<::MessageRef*>(p); } return _impl_.previousmessageref_; } -inline ::MessageRef* StreamMessage::mutable_previousmessageref() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::MessageRef* PROTOBUF_NONNULL StreamMessage::mutable_previousmessageref() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::MessageRef* _msg = _internal_mutable_previousmessageref(); // @@protoc_insertion_point(field_mutable:StreamMessage.previousMessageRef) return _msg; } -inline void StreamMessage::set_allocated_previousmessageref(::MessageRef* value) { +inline void StreamMessage::set_allocated_previousmessageref(::MessageRef* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::MessageRef*>(_impl_.previousmessageref_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.previousmessageref_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::MessageRef*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.previousmessageref_ = reinterpret_cast<::MessageRef*>(value); @@ -4789,61 +4917,75 @@ inline void StreamMessage::set_allocated_previousmessageref(::MessageRef* value) // bytes signature = 3; inline void StreamMessage::clear_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signature_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& StreamMessage::signature() const +inline const ::std::string& StreamMessage::signature() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamMessage.signature) return _internal_signature(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamMessage::set_signature(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StreamMessage::set_signature(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.signature_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamMessage.signature) } -inline std::string* StreamMessage::mutable_signature() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_signature(); +inline ::std::string* PROTOBUF_NONNULL StreamMessage::mutable_signature() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_signature(); // @@protoc_insertion_point(field_mutable:StreamMessage.signature) return _s; } -inline const std::string& StreamMessage::_internal_signature() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamMessage::_internal_signature() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.signature_.Get(); } -inline void StreamMessage::_internal_set_signature(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StreamMessage::_internal_set_signature(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signature_.Set(value, GetArena()); } -inline std::string* StreamMessage::_internal_mutable_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StreamMessage::_internal_mutable_signature() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.signature_.Mutable( GetArena()); } -inline std::string* StreamMessage::release_signature() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamMessage::release_signature() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamMessage.signature) - return _impl_.signature_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.signature_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.signature_.Set("", GetArena()); + } + return released; } -inline void StreamMessage::set_allocated_signature(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamMessage::set_allocated_signature(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.signature_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamMessage.signature) } // .SignatureType signatureType = 4; inline void StreamMessage::clear_signaturetype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signaturetype_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline ::SignatureType StreamMessage::signaturetype() const { // @@protoc_insertion_point(field_get:StreamMessage.signatureType) @@ -4851,15 +4993,15 @@ inline ::SignatureType StreamMessage::signaturetype() const { } inline void StreamMessage::set_signaturetype(::SignatureType value) { _internal_set_signaturetype(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:StreamMessage.signatureType) } inline ::SignatureType StreamMessage::_internal_signaturetype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::SignatureType>(_impl_.signaturetype_); } inline void StreamMessage::_internal_set_signaturetype(::SignatureType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.signaturetype_ = value; } @@ -4874,19 +5016,21 @@ inline void StreamMessage::set_has_contentmessage() { _impl_._oneof_case_[0] = kContentMessage; } inline void StreamMessage::clear_contentmessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kContentMessage) { if (GetArena() == nullptr) { delete _impl_.body_.contentmessage_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.contentmessage_); } clear_has_body(); } } -inline ::ContentMessage* StreamMessage::release_contentmessage() { +inline ::ContentMessage* PROTOBUF_NULLABLE StreamMessage::release_contentmessage() { // @@protoc_insertion_point(field_release:StreamMessage.contentMessage) if (body_case() == kContentMessage) { clear_has_body(); - auto* temp = _impl_.body_.contentmessage_; + auto* temp = reinterpret_cast<::ContentMessage*>(_impl_.body_.contentmessage_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -4897,43 +5041,47 @@ inline ::ContentMessage* StreamMessage::release_contentmessage() { } } inline const ::ContentMessage& StreamMessage::_internal_contentmessage() const { - return body_case() == kContentMessage ? *_impl_.body_.contentmessage_ : reinterpret_cast<::ContentMessage&>(::_ContentMessage_default_instance_); + return body_case() == kContentMessage ? static_cast(*reinterpret_cast<::ContentMessage*>(_impl_.body_.contentmessage_)) + : reinterpret_cast(::_ContentMessage_default_instance_); } inline const ::ContentMessage& StreamMessage::contentmessage() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamMessage.contentMessage) return _internal_contentmessage(); } -inline ::ContentMessage* StreamMessage::unsafe_arena_release_contentmessage() { +inline ::ContentMessage* PROTOBUF_NULLABLE StreamMessage::unsafe_arena_release_contentmessage() { // @@protoc_insertion_point(field_unsafe_arena_release:StreamMessage.contentMessage) if (body_case() == kContentMessage) { clear_has_body(); - auto* temp = _impl_.body_.contentmessage_; + auto* temp = reinterpret_cast<::ContentMessage*>(_impl_.body_.contentmessage_); _impl_.body_.contentmessage_ = nullptr; return temp; } else { return nullptr; } } -inline void StreamMessage::unsafe_arena_set_allocated_contentmessage(::ContentMessage* value) { +inline void StreamMessage::unsafe_arena_set_allocated_contentmessage( + ::ContentMessage* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_contentmessage(); - _impl_.body_.contentmessage_ = value; + _impl_.body_.contentmessage_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:StreamMessage.contentMessage) } -inline ::ContentMessage* StreamMessage::_internal_mutable_contentmessage() { +inline ::ContentMessage* PROTOBUF_NONNULL StreamMessage::_internal_mutable_contentmessage() { if (body_case() != kContentMessage) { clear_body(); set_has_contentmessage(); - _impl_.body_.contentmessage_ = CreateMaybeMessage<::ContentMessage>(GetArena()); + _impl_.body_.contentmessage_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::ContentMessage>(GetArena())); } - return _impl_.body_.contentmessage_; + return reinterpret_cast<::ContentMessage*>(_impl_.body_.contentmessage_); } -inline ::ContentMessage* StreamMessage::mutable_contentmessage() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::ContentMessage* PROTOBUF_NONNULL StreamMessage::mutable_contentmessage() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::ContentMessage* _msg = _internal_mutable_contentmessage(); // @@protoc_insertion_point(field_mutable:StreamMessage.contentMessage) return _msg; @@ -4950,19 +5098,21 @@ inline void StreamMessage::set_has_groupkeyrequest() { _impl_._oneof_case_[0] = kGroupKeyRequest; } inline void StreamMessage::clear_groupkeyrequest() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kGroupKeyRequest) { if (GetArena() == nullptr) { delete _impl_.body_.groupkeyrequest_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.groupkeyrequest_); } clear_has_body(); } } -inline ::GroupKeyRequest* StreamMessage::release_groupkeyrequest() { +inline ::GroupKeyRequest* PROTOBUF_NULLABLE StreamMessage::release_groupkeyrequest() { // @@protoc_insertion_point(field_release:StreamMessage.groupKeyRequest) if (body_case() == kGroupKeyRequest) { clear_has_body(); - auto* temp = _impl_.body_.groupkeyrequest_; + auto* temp = reinterpret_cast<::GroupKeyRequest*>(_impl_.body_.groupkeyrequest_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -4973,43 +5123,47 @@ inline ::GroupKeyRequest* StreamMessage::release_groupkeyrequest() { } } inline const ::GroupKeyRequest& StreamMessage::_internal_groupkeyrequest() const { - return body_case() == kGroupKeyRequest ? *_impl_.body_.groupkeyrequest_ : reinterpret_cast<::GroupKeyRequest&>(::_GroupKeyRequest_default_instance_); + return body_case() == kGroupKeyRequest ? static_cast(*reinterpret_cast<::GroupKeyRequest*>(_impl_.body_.groupkeyrequest_)) + : reinterpret_cast(::_GroupKeyRequest_default_instance_); } inline const ::GroupKeyRequest& StreamMessage::groupkeyrequest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamMessage.groupKeyRequest) return _internal_groupkeyrequest(); } -inline ::GroupKeyRequest* StreamMessage::unsafe_arena_release_groupkeyrequest() { +inline ::GroupKeyRequest* PROTOBUF_NULLABLE StreamMessage::unsafe_arena_release_groupkeyrequest() { // @@protoc_insertion_point(field_unsafe_arena_release:StreamMessage.groupKeyRequest) if (body_case() == kGroupKeyRequest) { clear_has_body(); - auto* temp = _impl_.body_.groupkeyrequest_; + auto* temp = reinterpret_cast<::GroupKeyRequest*>(_impl_.body_.groupkeyrequest_); _impl_.body_.groupkeyrequest_ = nullptr; return temp; } else { return nullptr; } } -inline void StreamMessage::unsafe_arena_set_allocated_groupkeyrequest(::GroupKeyRequest* value) { +inline void StreamMessage::unsafe_arena_set_allocated_groupkeyrequest( + ::GroupKeyRequest* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_groupkeyrequest(); - _impl_.body_.groupkeyrequest_ = value; + _impl_.body_.groupkeyrequest_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:StreamMessage.groupKeyRequest) } -inline ::GroupKeyRequest* StreamMessage::_internal_mutable_groupkeyrequest() { +inline ::GroupKeyRequest* PROTOBUF_NONNULL StreamMessage::_internal_mutable_groupkeyrequest() { if (body_case() != kGroupKeyRequest) { clear_body(); set_has_groupkeyrequest(); - _impl_.body_.groupkeyrequest_ = CreateMaybeMessage<::GroupKeyRequest>(GetArena()); + _impl_.body_.groupkeyrequest_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::GroupKeyRequest>(GetArena())); } - return _impl_.body_.groupkeyrequest_; + return reinterpret_cast<::GroupKeyRequest*>(_impl_.body_.groupkeyrequest_); } -inline ::GroupKeyRequest* StreamMessage::mutable_groupkeyrequest() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::GroupKeyRequest* PROTOBUF_NONNULL StreamMessage::mutable_groupkeyrequest() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::GroupKeyRequest* _msg = _internal_mutable_groupkeyrequest(); // @@protoc_insertion_point(field_mutable:StreamMessage.groupKeyRequest) return _msg; @@ -5026,19 +5180,21 @@ inline void StreamMessage::set_has_groupkeyresponse() { _impl_._oneof_case_[0] = kGroupKeyResponse; } inline void StreamMessage::clear_groupkeyresponse() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (body_case() == kGroupKeyResponse) { if (GetArena() == nullptr) { delete _impl_.body_.groupkeyresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.body_.groupkeyresponse_); } clear_has_body(); } } -inline ::GroupKeyResponse* StreamMessage::release_groupkeyresponse() { +inline ::GroupKeyResponse* PROTOBUF_NULLABLE StreamMessage::release_groupkeyresponse() { // @@protoc_insertion_point(field_release:StreamMessage.groupKeyResponse) if (body_case() == kGroupKeyResponse) { clear_has_body(); - auto* temp = _impl_.body_.groupkeyresponse_; + auto* temp = reinterpret_cast<::GroupKeyResponse*>(_impl_.body_.groupkeyresponse_); if (GetArena() != nullptr) { temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); } @@ -5049,43 +5205,47 @@ inline ::GroupKeyResponse* StreamMessage::release_groupkeyresponse() { } } inline const ::GroupKeyResponse& StreamMessage::_internal_groupkeyresponse() const { - return body_case() == kGroupKeyResponse ? *_impl_.body_.groupkeyresponse_ : reinterpret_cast<::GroupKeyResponse&>(::_GroupKeyResponse_default_instance_); + return body_case() == kGroupKeyResponse ? static_cast(*reinterpret_cast<::GroupKeyResponse*>(_impl_.body_.groupkeyresponse_)) + : reinterpret_cast(::_GroupKeyResponse_default_instance_); } inline const ::GroupKeyResponse& StreamMessage::groupkeyresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamMessage.groupKeyResponse) return _internal_groupkeyresponse(); } -inline ::GroupKeyResponse* StreamMessage::unsafe_arena_release_groupkeyresponse() { +inline ::GroupKeyResponse* PROTOBUF_NULLABLE StreamMessage::unsafe_arena_release_groupkeyresponse() { // @@protoc_insertion_point(field_unsafe_arena_release:StreamMessage.groupKeyResponse) if (body_case() == kGroupKeyResponse) { clear_has_body(); - auto* temp = _impl_.body_.groupkeyresponse_; + auto* temp = reinterpret_cast<::GroupKeyResponse*>(_impl_.body_.groupkeyresponse_); _impl_.body_.groupkeyresponse_ = nullptr; return temp; } else { return nullptr; } } -inline void StreamMessage::unsafe_arena_set_allocated_groupkeyresponse(::GroupKeyResponse* value) { +inline void StreamMessage::unsafe_arena_set_allocated_groupkeyresponse( + ::GroupKeyResponse* PROTOBUF_NULLABLE 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_body(); if (value) { set_has_groupkeyresponse(); - _impl_.body_.groupkeyresponse_ = value; + _impl_.body_.groupkeyresponse_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:StreamMessage.groupKeyResponse) } -inline ::GroupKeyResponse* StreamMessage::_internal_mutable_groupkeyresponse() { +inline ::GroupKeyResponse* PROTOBUF_NONNULL StreamMessage::_internal_mutable_groupkeyresponse() { if (body_case() != kGroupKeyResponse) { clear_body(); set_has_groupkeyresponse(); - _impl_.body_.groupkeyresponse_ = CreateMaybeMessage<::GroupKeyResponse>(GetArena()); + _impl_.body_.groupkeyresponse_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::GroupKeyResponse>(GetArena())); } - return _impl_.body_.groupkeyresponse_; + return reinterpret_cast<::GroupKeyResponse*>(_impl_.body_.groupkeyresponse_); } -inline ::GroupKeyResponse* StreamMessage::mutable_groupkeyresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::GroupKeyResponse* PROTOBUF_NONNULL StreamMessage::mutable_groupkeyresponse() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::GroupKeyResponse* _msg = _internal_mutable_groupkeyresponse(); // @@protoc_insertion_point(field_mutable:StreamMessage.groupKeyResponse) return _msg; @@ -5106,61 +5266,75 @@ inline StreamMessage::BodyCase StreamMessage::body_case() const { // bytes content = 1; inline void ContentMessage::clear_content() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.content_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ContentMessage::content() const +inline const ::std::string& ContentMessage::content() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:ContentMessage.content) return _internal_content(); } template -inline PROTOBUF_ALWAYS_INLINE void ContentMessage::set_content(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ContentMessage::set_content(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.content_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:ContentMessage.content) } -inline std::string* ContentMessage::mutable_content() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_content(); +inline ::std::string* PROTOBUF_NONNULL ContentMessage::mutable_content() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_content(); // @@protoc_insertion_point(field_mutable:ContentMessage.content) return _s; } -inline const std::string& ContentMessage::_internal_content() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ContentMessage::_internal_content() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.content_.Get(); } -inline void ContentMessage::_internal_set_content(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ContentMessage::_internal_set_content(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.content_.Set(value, GetArena()); } -inline std::string* ContentMessage::_internal_mutable_content() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ContentMessage::_internal_mutable_content() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.content_.Mutable( GetArena()); } -inline std::string* ContentMessage::release_content() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ContentMessage::release_content() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ContentMessage.content) - return _impl_.content_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.content_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.content_.Set("", GetArena()); + } + return released; } -inline void ContentMessage::set_allocated_content(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ContentMessage::set_allocated_content(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.content_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.content_.IsDefault()) { - _impl_.content_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.content_.IsDefault()) { + _impl_.content_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:ContentMessage.content) } // .ContentType contentType = 2; inline void ContentMessage::clear_contenttype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.contenttype_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline ::ContentType ContentMessage::contenttype() const { // @@protoc_insertion_point(field_get:ContentMessage.contentType) @@ -5168,22 +5342,24 @@ inline ::ContentType ContentMessage::contenttype() const { } inline void ContentMessage::set_contenttype(::ContentType value) { _internal_set_contenttype(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); // @@protoc_insertion_point(field_set:ContentMessage.contentType) } inline ::ContentType ContentMessage::_internal_contenttype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::ContentType>(_impl_.contenttype_); } inline void ContentMessage::_internal_set_contenttype(::ContentType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.contenttype_ = value; } // .EncryptionType encryptionType = 3; inline void ContentMessage::clear_encryptiontype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.encryptiontype_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } inline ::EncryptionType ContentMessage::encryptiontype() const { // @@protoc_insertion_point(field_get:ContentMessage.encryptionType) @@ -5191,102 +5367,101 @@ inline ::EncryptionType ContentMessage::encryptiontype() const { } inline void ContentMessage::set_encryptiontype(::EncryptionType value) { _internal_set_encryptiontype(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); // @@protoc_insertion_point(field_set:ContentMessage.encryptionType) } inline ::EncryptionType ContentMessage::_internal_encryptiontype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::EncryptionType>(_impl_.encryptiontype_); } inline void ContentMessage::_internal_set_encryptiontype(::EncryptionType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.encryptiontype_ = value; } // optional string groupKeyId = 4; inline bool ContentMessage::has_groupkeyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void ContentMessage::clear_groupkeyid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.groupkeyid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& ContentMessage::groupkeyid() const +inline const ::std::string& ContentMessage::groupkeyid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:ContentMessage.groupKeyId) return _internal_groupkeyid(); } template -inline PROTOBUF_ALWAYS_INLINE void ContentMessage::set_groupkeyid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void ContentMessage::set_groupkeyid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.groupkeyid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:ContentMessage.groupKeyId) } -inline std::string* ContentMessage::mutable_groupkeyid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_groupkeyid(); +inline ::std::string* PROTOBUF_NONNULL ContentMessage::mutable_groupkeyid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_groupkeyid(); // @@protoc_insertion_point(field_mutable:ContentMessage.groupKeyId) return _s; } -inline const std::string& ContentMessage::_internal_groupkeyid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ContentMessage::_internal_groupkeyid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.groupkeyid_.Get(); } -inline void ContentMessage::_internal_set_groupkeyid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void ContentMessage::_internal_set_groupkeyid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.groupkeyid_.Set(value, GetArena()); } -inline std::string* ContentMessage::_internal_mutable_groupkeyid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL ContentMessage::_internal_mutable_groupkeyid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.groupkeyid_.Mutable( GetArena()); } -inline std::string* ContentMessage::release_groupkeyid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ContentMessage::release_groupkeyid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ContentMessage.groupKeyId) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); auto* released = _impl_.groupkeyid_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupkeyid_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.groupkeyid_.Set("", GetArena()); + } return released; } -inline void ContentMessage::set_allocated_groupkeyid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ContentMessage::set_allocated_groupkeyid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.groupkeyid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupkeyid_.IsDefault()) { - _impl_.groupkeyid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.groupkeyid_.IsDefault()) { + _impl_.groupkeyid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:ContentMessage.groupKeyId) } // optional .GroupKey newGroupKey = 5; inline bool ContentMessage::has_newgroupkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.newgroupkey_ != nullptr); return value; } inline void ContentMessage::clear_newgroupkey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.newgroupkey_ != nullptr) _impl_.newgroupkey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline const ::GroupKey& ContentMessage::_internal_newgroupkey() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::GroupKey* p = _impl_.newgroupkey_; return p != nullptr ? *p : reinterpret_cast(::_GroupKey_default_instance_); } @@ -5294,76 +5469,78 @@ inline const ::GroupKey& ContentMessage::newgroupkey() const ABSL_ATTRIBUTE_LIFE // @@protoc_insertion_point(field_get:ContentMessage.newGroupKey) return _internal_newgroupkey(); } -inline void ContentMessage::unsafe_arena_set_allocated_newgroupkey(::GroupKey* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ContentMessage::unsafe_arena_set_allocated_newgroupkey( + ::GroupKey* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.newgroupkey_); } _impl_.newgroupkey_ = reinterpret_cast<::GroupKey*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ContentMessage.newGroupKey) } -inline ::GroupKey* ContentMessage::release_newgroupkey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::GroupKey* PROTOBUF_NULLABLE ContentMessage::release_newgroupkey() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::GroupKey* released = _impl_.newgroupkey_; _impl_.newgroupkey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::GroupKey* ContentMessage::unsafe_arena_release_newgroupkey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::GroupKey* PROTOBUF_NULLABLE ContentMessage::unsafe_arena_release_newgroupkey() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ContentMessage.newGroupKey) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::GroupKey* temp = _impl_.newgroupkey_; _impl_.newgroupkey_ = nullptr; return temp; } -inline ::GroupKey* ContentMessage::_internal_mutable_newgroupkey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::GroupKey* PROTOBUF_NONNULL ContentMessage::_internal_mutable_newgroupkey() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.newgroupkey_ == nullptr) { - auto* p = CreateMaybeMessage<::GroupKey>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::GroupKey>(GetArena()); _impl_.newgroupkey_ = reinterpret_cast<::GroupKey*>(p); } return _impl_.newgroupkey_; } -inline ::GroupKey* ContentMessage::mutable_newgroupkey() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::GroupKey* PROTOBUF_NONNULL ContentMessage::mutable_newgroupkey() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::GroupKey* _msg = _internal_mutable_newgroupkey(); // @@protoc_insertion_point(field_mutable:ContentMessage.newGroupKey) return _msg; } -inline void ContentMessage::set_allocated_newgroupkey(::GroupKey* value) { +inline void ContentMessage::set_allocated_newgroupkey(::GroupKey* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::GroupKey*>(_impl_.newgroupkey_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.newgroupkey_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::GroupKey*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.newgroupkey_ = reinterpret_cast<::GroupKey*>(value); @@ -5376,160 +5553,196 @@ inline void ContentMessage::set_allocated_newgroupkey(::GroupKey* value) { // string requestId = 1; inline void GroupKeyRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& GroupKeyRequest::requestid() const +inline const ::std::string& GroupKeyRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKeyRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKeyRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKeyRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKeyRequest.requestId) } -inline std::string* GroupKeyRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:GroupKeyRequest.requestId) return _s; } -inline const std::string& GroupKeyRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKeyRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void GroupKeyRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKeyRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* GroupKeyRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* GroupKeyRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKeyRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKeyRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void GroupKeyRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKeyRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKeyRequest.requestId) } // bytes recipientId = 2; inline void GroupKeyRequest::clear_recipientid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.recipientid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& GroupKeyRequest::recipientid() const +inline const ::std::string& GroupKeyRequest::recipientid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKeyRequest.recipientId) return _internal_recipientid(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKeyRequest::set_recipientid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKeyRequest::set_recipientid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.recipientid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKeyRequest.recipientId) } -inline std::string* GroupKeyRequest::mutable_recipientid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_recipientid(); +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::mutable_recipientid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_recipientid(); // @@protoc_insertion_point(field_mutable:GroupKeyRequest.recipientId) return _s; } -inline const std::string& GroupKeyRequest::_internal_recipientid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKeyRequest::_internal_recipientid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.recipientid_.Get(); } -inline void GroupKeyRequest::_internal_set_recipientid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKeyRequest::_internal_set_recipientid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.recipientid_.Set(value, GetArena()); } -inline std::string* GroupKeyRequest::_internal_mutable_recipientid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::_internal_mutable_recipientid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.recipientid_.Mutable( GetArena()); } -inline std::string* GroupKeyRequest::release_recipientid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKeyRequest::release_recipientid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKeyRequest.recipientId) - return _impl_.recipientid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.recipientid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.recipientid_.Set("", GetArena()); + } + return released; } -inline void GroupKeyRequest::set_allocated_recipientid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKeyRequest::set_allocated_recipientid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.recipientid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.recipientid_.IsDefault()) { - _impl_.recipientid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.recipientid_.IsDefault()) { + _impl_.recipientid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKeyRequest.recipientId) } // bytes rsaPublicKey = 3; inline void GroupKeyRequest::clear_rsapublickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rsapublickey_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& GroupKeyRequest::rsapublickey() const +inline const ::std::string& GroupKeyRequest::rsapublickey() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKeyRequest.rsaPublicKey) return _internal_rsapublickey(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKeyRequest::set_rsapublickey(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKeyRequest::set_rsapublickey(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.rsapublickey_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKeyRequest.rsaPublicKey) } -inline std::string* GroupKeyRequest::mutable_rsapublickey() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_rsapublickey(); +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::mutable_rsapublickey() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_rsapublickey(); // @@protoc_insertion_point(field_mutable:GroupKeyRequest.rsaPublicKey) return _s; } -inline const std::string& GroupKeyRequest::_internal_rsapublickey() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKeyRequest::_internal_rsapublickey() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rsapublickey_.Get(); } -inline void GroupKeyRequest::_internal_set_rsapublickey(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKeyRequest::_internal_set_rsapublickey(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rsapublickey_.Set(value, GetArena()); } -inline std::string* GroupKeyRequest::_internal_mutable_rsapublickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::_internal_mutable_rsapublickey() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.rsapublickey_.Mutable( GetArena()); } -inline std::string* GroupKeyRequest::release_rsapublickey() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKeyRequest::release_rsapublickey() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKeyRequest.rsaPublicKey) - return _impl_.rsapublickey_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + auto* released = _impl_.rsapublickey_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.rsapublickey_.Set("", GetArena()); + } + return released; } -inline void GroupKeyRequest::set_allocated_rsapublickey(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKeyRequest::set_allocated_rsapublickey(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + } _impl_.rsapublickey_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rsapublickey_.IsDefault()) { - _impl_.rsapublickey_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.rsapublickey_.IsDefault()) { + _impl_.rsapublickey_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKeyRequest.rsaPublicKey) } @@ -5541,96 +5754,67 @@ inline int GroupKeyRequest::groupkeyids_size() const { return _internal_groupkeyids_size(); } inline void GroupKeyRequest::clear_groupkeyids() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.groupkeyids_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline std::string* GroupKeyRequest::add_groupkeyids() +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::add_groupkeyids() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - std::string* _s = _internal_mutable_groupkeyids()->Add(); + ::google::protobuf::internal::TSanWrite(&_impl_); + ::std::string* _s = + _internal_mutable_groupkeyids()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add_mutable:GroupKeyRequest.groupKeyIds) return _s; } -inline const std::string& GroupKeyRequest::groupkeyids(int index) const +inline const ::std::string& GroupKeyRequest::groupkeyids(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKeyRequest.groupKeyIds) return _internal_groupkeyids().Get(index); } -inline std::string* GroupKeyRequest::mutable_groupkeyids(int index) +inline ::std::string* PROTOBUF_NONNULL GroupKeyRequest::mutable_groupkeyids(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:GroupKeyRequest.groupKeyIds) return _internal_mutable_groupkeyids()->Mutable(index); } -inline void GroupKeyRequest::set_groupkeyids(int index, const std::string& value) { - _internal_mutable_groupkeyids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::set_groupkeyids(int index, std::string&& value) { - _internal_mutable_groupkeyids()->Mutable(index)->assign(std::move(value)); +template +inline void GroupKeyRequest::set_groupkeyids(int index, Arg_&& value, Args_... args) { + ::google::protobuf::internal::AssignToString(*_internal_mutable_groupkeyids()->Mutable(index), ::std::forward(value), + args... ); // @@protoc_insertion_point(field_set:GroupKeyRequest.groupKeyIds) } -inline void GroupKeyRequest::set_groupkeyids(int index, const char* value) { - ABSL_DCHECK(value != nullptr); - _internal_mutable_groupkeyids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::set_groupkeyids(int index, const char* value, - std::size_t size) { - _internal_mutable_groupkeyids()->Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::set_groupkeyids(int index, absl::string_view value) { - _internal_mutable_groupkeyids()->Mutable(index)->assign(value.data(), - value.size()); - // @@protoc_insertion_point(field_set_string_piece:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::add_groupkeyids(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_groupkeyids()->Add()->assign(value); - // @@protoc_insertion_point(field_add:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::add_groupkeyids(std::string&& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_groupkeyids()->Add(std::move(value)); +template +inline void GroupKeyRequest::add_groupkeyids(Arg_&& value, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::google::protobuf::internal::AddToRepeatedPtrField( + ::google::protobuf::MessageLite::internal_visibility(), GetArena(), + *_internal_mutable_groupkeyids(), ::std::forward(value), + args... ); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:GroupKeyRequest.groupKeyIds) } -inline void GroupKeyRequest::add_groupkeyids(const char* value) { - ABSL_DCHECK(value != nullptr); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_groupkeyids()->Add()->assign(value); - // @@protoc_insertion_point(field_add_char:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::add_groupkeyids(const char* value, std::size_t size) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_groupkeyids()->Add()->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:GroupKeyRequest.groupKeyIds) -} -inline void GroupKeyRequest::add_groupkeyids(absl::string_view value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_groupkeyids()->Add()->assign(value.data(), value.size()); - // @@protoc_insertion_point(field_add_string_piece:GroupKeyRequest.groupKeyIds) -} -inline const ::google::protobuf::RepeatedPtrField& -GroupKeyRequest::groupkeyids() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::RepeatedPtrField<::std::string>& GroupKeyRequest::groupkeyids() + const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:GroupKeyRequest.groupKeyIds) return _internal_groupkeyids(); } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL GroupKeyRequest::mutable_groupkeyids() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:GroupKeyRequest.groupKeyIds) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_groupkeyids(); } -inline const ::google::protobuf::RepeatedPtrField& +inline const ::google::protobuf::RepeatedPtrField<::std::string>& GroupKeyRequest::_internal_groupkeyids() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.groupkeyids_; } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL GroupKeyRequest::_internal_mutable_groupkeyids() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.groupkeyids_; } @@ -5640,107 +5824,131 @@ GroupKeyRequest::_internal_mutable_groupkeyids() { // string requestId = 1; inline void GroupKeyResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& GroupKeyResponse::requestid() const +inline const ::std::string& GroupKeyResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKeyResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKeyResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKeyResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKeyResponse.requestId) } -inline std::string* GroupKeyResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL GroupKeyResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:GroupKeyResponse.requestId) return _s; } -inline const std::string& GroupKeyResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKeyResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void GroupKeyResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKeyResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* GroupKeyResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKeyResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* GroupKeyResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKeyResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKeyResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void GroupKeyResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKeyResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKeyResponse.requestId) } // bytes recipientId = 2; inline void GroupKeyResponse::clear_recipientid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.recipientid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& GroupKeyResponse::recipientid() const +inline const ::std::string& GroupKeyResponse::recipientid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKeyResponse.recipientId) return _internal_recipientid(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKeyResponse::set_recipientid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKeyResponse::set_recipientid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.recipientid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKeyResponse.recipientId) } -inline std::string* GroupKeyResponse::mutable_recipientid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_recipientid(); +inline ::std::string* PROTOBUF_NONNULL GroupKeyResponse::mutable_recipientid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_recipientid(); // @@protoc_insertion_point(field_mutable:GroupKeyResponse.recipientId) return _s; } -inline const std::string& GroupKeyResponse::_internal_recipientid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKeyResponse::_internal_recipientid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.recipientid_.Get(); } -inline void GroupKeyResponse::_internal_set_recipientid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKeyResponse::_internal_set_recipientid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.recipientid_.Set(value, GetArena()); } -inline std::string* GroupKeyResponse::_internal_mutable_recipientid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKeyResponse::_internal_mutable_recipientid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.recipientid_.Mutable( GetArena()); } -inline std::string* GroupKeyResponse::release_recipientid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKeyResponse::release_recipientid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKeyResponse.recipientId) - return _impl_.recipientid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.recipientid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.recipientid_.Set("", GetArena()); + } + return released; } -inline void GroupKeyResponse::set_allocated_recipientid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKeyResponse::set_allocated_recipientid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.recipientid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.recipientid_.IsDefault()) { - _impl_.recipientid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.recipientid_.IsDefault()) { + _impl_.recipientid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKeyResponse.recipientId) } @@ -5752,18 +5960,21 @@ inline int GroupKeyResponse::groupkeys_size() const { return _internal_groupkeys_size(); } inline void GroupKeyResponse::clear_groupkeys() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.groupkeys_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::GroupKey* GroupKeyResponse::mutable_groupkeys(int index) +inline ::GroupKey* PROTOBUF_NONNULL GroupKeyResponse::mutable_groupkeys(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:GroupKeyResponse.groupKeys) return _internal_mutable_groupkeys()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::GroupKey>* GroupKeyResponse::mutable_groupkeys() +inline ::google::protobuf::RepeatedPtrField<::GroupKey>* PROTOBUF_NONNULL GroupKeyResponse::mutable_groupkeys() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:GroupKeyResponse.groupKeys) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_groupkeys(); } inline const ::GroupKey& GroupKeyResponse::groupkeys(int index) const @@ -5771,9 +5982,13 @@ inline const ::GroupKey& GroupKeyResponse::groupkeys(int index) const // @@protoc_insertion_point(field_get:GroupKeyResponse.groupKeys) return _internal_groupkeys().Get(index); } -inline ::GroupKey* GroupKeyResponse::add_groupkeys() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::GroupKey* _add = _internal_mutable_groupkeys()->Add(); +inline ::GroupKey* PROTOBUF_NONNULL GroupKeyResponse::add_groupkeys() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::GroupKey* _add = + _internal_mutable_groupkeys()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:GroupKeyResponse.groupKeys) return _add; } @@ -5784,12 +5999,12 @@ inline const ::google::protobuf::RepeatedPtrField<::GroupKey>& GroupKeyResponse: } inline const ::google::protobuf::RepeatedPtrField<::GroupKey>& GroupKeyResponse::_internal_groupkeys() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.groupkeys_; } -inline ::google::protobuf::RepeatedPtrField<::GroupKey>* +inline ::google::protobuf::RepeatedPtrField<::GroupKey>* PROTOBUF_NONNULL GroupKeyResponse::_internal_mutable_groupkeys() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.groupkeys_; } @@ -5799,107 +6014,131 @@ GroupKeyResponse::_internal_mutable_groupkeys() { // string id = 1; inline void GroupKey::clear_id() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& GroupKey::id() const +inline const ::std::string& GroupKey::id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKey.id) return _internal_id(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKey::set_id(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKey::set_id(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.id_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKey.id) } -inline std::string* GroupKey::mutable_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_id(); +inline ::std::string* PROTOBUF_NONNULL GroupKey::mutable_id() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_id(); // @@protoc_insertion_point(field_mutable:GroupKey.id) return _s; } -inline const std::string& GroupKey::_internal_id() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKey::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_.Get(); } -inline void GroupKey::_internal_set_id(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKey::_internal_set_id(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(value, GetArena()); } -inline std::string* GroupKey::_internal_mutable_id() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKey::_internal_mutable_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.id_.Mutable( GetArena()); } -inline std::string* GroupKey::release_id() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKey::release_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKey.id) - return _impl_.id_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.id_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.id_.Set("", GetArena()); + } + return released; } -inline void GroupKey::set_allocated_id(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKey::set_allocated_id(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.id_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKey.id) } // bytes data = 2; inline void GroupKey::clear_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& GroupKey::data() const +inline const ::std::string& GroupKey::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:GroupKey.data) return _internal_data(); } template -inline PROTOBUF_ALWAYS_INLINE void GroupKey::set_data(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void GroupKey::set_data(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:GroupKey.data) } -inline std::string* GroupKey::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_data(); +inline ::std::string* PROTOBUF_NONNULL GroupKey::mutable_data() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:GroupKey.data) return _s; } -inline const std::string& GroupKey::_internal_data() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& GroupKey::_internal_data() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } -inline void GroupKey::_internal_set_data(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void GroupKey::_internal_set_data(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } -inline std::string* GroupKey::_internal_mutable_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL GroupKey::_internal_mutable_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } -inline std::string* GroupKey::release_data() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE GroupKey::release_data() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:GroupKey.data) - return _impl_.data_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.data_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.data_.Set("", GetArena()); + } + return released; } -inline void GroupKey::set_allocated_data(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void GroupKey::set_allocated_data(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.data_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.data_.IsDefault()) { - _impl_.data_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.data_.IsDefault()) { + _impl_.data_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:GroupKey.data) } @@ -5909,178 +6148,200 @@ inline void GroupKey::set_allocated_data(std::string* value) { // string streamPartId = 1; inline void StreamPartHandshakeRequest::clear_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& StreamPartHandshakeRequest::streampartid() const +inline const ::std::string& StreamPartHandshakeRequest::streampartid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartHandshakeRequest.streamPartId) return _internal_streampartid(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_streampartid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_streampartid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.streampartid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamPartHandshakeRequest.streamPartId) } -inline std::string* StreamPartHandshakeRequest::mutable_streampartid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_streampartid(); +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::mutable_streampartid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_streampartid(); // @@protoc_insertion_point(field_mutable:StreamPartHandshakeRequest.streamPartId) return _s; } -inline const std::string& StreamPartHandshakeRequest::_internal_streampartid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamPartHandshakeRequest::_internal_streampartid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.streampartid_.Get(); } -inline void StreamPartHandshakeRequest::_internal_set_streampartid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StreamPartHandshakeRequest::_internal_set_streampartid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartid_.Set(value, GetArena()); } -inline std::string* StreamPartHandshakeRequest::_internal_mutable_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::_internal_mutable_streampartid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.streampartid_.Mutable( GetArena()); } -inline std::string* StreamPartHandshakeRequest::release_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamPartHandshakeRequest::release_streampartid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartHandshakeRequest.streamPartId) - return _impl_.streampartid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.streampartid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.streampartid_.Set("", GetArena()); + } + return released; } -inline void StreamPartHandshakeRequest::set_allocated_streampartid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartHandshakeRequest::set_allocated_streampartid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.streampartid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streampartid_.IsDefault()) { - _impl_.streampartid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.streampartid_.IsDefault()) { + _impl_.streampartid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamPartHandshakeRequest.streamPartId) } // string requestId = 2; inline void StreamPartHandshakeRequest::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& StreamPartHandshakeRequest::requestid() const +inline const ::std::string& StreamPartHandshakeRequest::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartHandshakeRequest.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamPartHandshakeRequest.requestId) } -inline std::string* StreamPartHandshakeRequest::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:StreamPartHandshakeRequest.requestId) return _s; } -inline const std::string& StreamPartHandshakeRequest::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamPartHandshakeRequest::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void StreamPartHandshakeRequest::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StreamPartHandshakeRequest::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* StreamPartHandshakeRequest::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* StreamPartHandshakeRequest::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamPartHandshakeRequest::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartHandshakeRequest.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void StreamPartHandshakeRequest::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartHandshakeRequest::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamPartHandshakeRequest.requestId) } // optional bytes concurrentHandshakeNodeId = 3; inline bool StreamPartHandshakeRequest::has_concurrenthandshakenodeid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); return value; } inline void StreamPartHandshakeRequest::clear_concurrenthandshakenodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.concurrenthandshakenodeid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& StreamPartHandshakeRequest::concurrenthandshakenodeid() const +inline const ::std::string& StreamPartHandshakeRequest::concurrenthandshakenodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartHandshakeRequest.concurrentHandshakeNodeId) return _internal_concurrenthandshakenodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_concurrenthandshakenodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_concurrenthandshakenodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.concurrenthandshakenodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamPartHandshakeRequest.concurrentHandshakeNodeId) } -inline std::string* StreamPartHandshakeRequest::mutable_concurrenthandshakenodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_concurrenthandshakenodeid(); +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::mutable_concurrenthandshakenodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_concurrenthandshakenodeid(); // @@protoc_insertion_point(field_mutable:StreamPartHandshakeRequest.concurrentHandshakeNodeId) return _s; } -inline const std::string& StreamPartHandshakeRequest::_internal_concurrenthandshakenodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamPartHandshakeRequest::_internal_concurrenthandshakenodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.concurrenthandshakenodeid_.Get(); } -inline void StreamPartHandshakeRequest::_internal_set_concurrenthandshakenodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void StreamPartHandshakeRequest::_internal_set_concurrenthandshakenodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.concurrenthandshakenodeid_.Set(value, GetArena()); } -inline std::string* StreamPartHandshakeRequest::_internal_mutable_concurrenthandshakenodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::_internal_mutable_concurrenthandshakenodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.concurrenthandshakenodeid_.Mutable( GetArena()); } -inline std::string* StreamPartHandshakeRequest::release_concurrenthandshakenodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamPartHandshakeRequest::release_concurrenthandshakenodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartHandshakeRequest.concurrentHandshakeNodeId) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); auto* released = _impl_.concurrenthandshakenodeid_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.concurrenthandshakenodeid_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.concurrenthandshakenodeid_.Set("", GetArena()); + } return released; } -inline void StreamPartHandshakeRequest::set_allocated_concurrenthandshakenodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartHandshakeRequest::set_allocated_concurrenthandshakenodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.concurrenthandshakenodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.concurrenthandshakenodeid_.IsDefault()) { - _impl_.concurrenthandshakenodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.concurrenthandshakenodeid_.IsDefault()) { + _impl_.concurrenthandshakenodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamPartHandshakeRequest.concurrentHandshakeNodeId) } @@ -6092,167 +6353,136 @@ inline int StreamPartHandshakeRequest::neighbornodeids_size() const { return _internal_neighbornodeids_size(); } inline void StreamPartHandshakeRequest::clear_neighbornodeids() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.neighbornodeids_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline std::string* StreamPartHandshakeRequest::add_neighbornodeids() +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::add_neighbornodeids() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - std::string* _s = _internal_mutable_neighbornodeids()->Add(); + ::google::protobuf::internal::TSanWrite(&_impl_); + ::std::string* _s = + _internal_mutable_neighbornodeids()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add_mutable:StreamPartHandshakeRequest.neighborNodeIds) return _s; } -inline const std::string& StreamPartHandshakeRequest::neighbornodeids(int index) const +inline const ::std::string& StreamPartHandshakeRequest::neighbornodeids(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartHandshakeRequest.neighborNodeIds) return _internal_neighbornodeids().Get(index); } -inline std::string* StreamPartHandshakeRequest::mutable_neighbornodeids(int index) +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::mutable_neighbornodeids(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:StreamPartHandshakeRequest.neighborNodeIds) return _internal_mutable_neighbornodeids()->Mutable(index); } -inline void StreamPartHandshakeRequest::set_neighbornodeids(int index, const std::string& value) { - _internal_mutable_neighbornodeids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::set_neighbornodeids(int index, std::string&& value) { - _internal_mutable_neighbornodeids()->Mutable(index)->assign(std::move(value)); +template +inline void StreamPartHandshakeRequest::set_neighbornodeids(int index, Arg_&& value, Args_... args) { + ::google::protobuf::internal::AssignToString(*_internal_mutable_neighbornodeids()->Mutable(index), ::std::forward(value), + args... , ::google::protobuf::internal::BytesTag{}); // @@protoc_insertion_point(field_set:StreamPartHandshakeRequest.neighborNodeIds) } -inline void StreamPartHandshakeRequest::set_neighbornodeids(int index, const char* value) { - ABSL_DCHECK(value != nullptr); - _internal_mutable_neighbornodeids()->Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::set_neighbornodeids(int index, const void* value, - std::size_t size) { - _internal_mutable_neighbornodeids()->Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::set_neighbornodeids(int index, absl::string_view value) { - _internal_mutable_neighbornodeids()->Mutable(index)->assign(value.data(), - value.size()); - // @@protoc_insertion_point(field_set_string_piece:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::add_neighbornodeids(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_neighbornodeids()->Add()->assign(value); - // @@protoc_insertion_point(field_add:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::add_neighbornodeids(std::string&& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_neighbornodeids()->Add(std::move(value)); +template +inline void StreamPartHandshakeRequest::add_neighbornodeids(Arg_&& value, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::google::protobuf::internal::AddToRepeatedPtrField( + ::google::protobuf::MessageLite::internal_visibility(), GetArena(), + *_internal_mutable_neighbornodeids(), ::std::forward(value), + args... , ::google::protobuf::internal::BytesTag{}); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:StreamPartHandshakeRequest.neighborNodeIds) } -inline void StreamPartHandshakeRequest::add_neighbornodeids(const char* value) { - ABSL_DCHECK(value != nullptr); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_neighbornodeids()->Add()->assign(value); - // @@protoc_insertion_point(field_add_char:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::add_neighbornodeids(const void* value, std::size_t size) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_neighbornodeids()->Add()->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:StreamPartHandshakeRequest.neighborNodeIds) -} -inline void StreamPartHandshakeRequest::add_neighbornodeids(absl::string_view value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _internal_mutable_neighbornodeids()->Add()->assign(value.data(), value.size()); - // @@protoc_insertion_point(field_add_string_piece:StreamPartHandshakeRequest.neighborNodeIds) -} -inline const ::google::protobuf::RepeatedPtrField& -StreamPartHandshakeRequest::neighbornodeids() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::RepeatedPtrField<::std::string>& StreamPartHandshakeRequest::neighbornodeids() + const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:StreamPartHandshakeRequest.neighborNodeIds) return _internal_neighbornodeids(); } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL StreamPartHandshakeRequest::mutable_neighbornodeids() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:StreamPartHandshakeRequest.neighborNodeIds) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_neighbornodeids(); } -inline const ::google::protobuf::RepeatedPtrField& +inline const ::google::protobuf::RepeatedPtrField<::std::string>& StreamPartHandshakeRequest::_internal_neighbornodeids() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.neighbornodeids_; } -inline ::google::protobuf::RepeatedPtrField* +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL StreamPartHandshakeRequest::_internal_mutable_neighbornodeids() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.neighbornodeids_; } // optional bytes interleaveNodeId = 5; inline bool StreamPartHandshakeRequest::has_interleavenodeid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); return value; } inline void StreamPartHandshakeRequest::clear_interleavenodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.interleavenodeid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -inline const std::string& StreamPartHandshakeRequest::interleavenodeid() const +inline const ::std::string& StreamPartHandshakeRequest::interleavenodeid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartHandshakeRequest.interleaveNodeId) return _internal_interleavenodeid(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_interleavenodeid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeRequest::set_interleavenodeid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); _impl_.interleavenodeid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamPartHandshakeRequest.interleaveNodeId) } -inline std::string* StreamPartHandshakeRequest::mutable_interleavenodeid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_interleavenodeid(); +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::mutable_interleavenodeid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + ::std::string* _s = _internal_mutable_interleavenodeid(); // @@protoc_insertion_point(field_mutable:StreamPartHandshakeRequest.interleaveNodeId) return _s; } -inline const std::string& StreamPartHandshakeRequest::_internal_interleavenodeid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamPartHandshakeRequest::_internal_interleavenodeid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.interleavenodeid_.Get(); } -inline void StreamPartHandshakeRequest::_internal_set_interleavenodeid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline void StreamPartHandshakeRequest::_internal_set_interleavenodeid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.interleavenodeid_.Set(value, GetArena()); } -inline std::string* StreamPartHandshakeRequest::_internal_mutable_interleavenodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeRequest::_internal_mutable_interleavenodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.interleavenodeid_.Mutable( GetArena()); } -inline std::string* StreamPartHandshakeRequest::release_interleavenodeid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamPartHandshakeRequest::release_interleavenodeid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartHandshakeRequest.interleaveNodeId) - if ((_impl_._has_bits_[0] & 0x00000002u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); auto* released = _impl_.interleavenodeid_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.interleavenodeid_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.interleavenodeid_.Set("", GetArena()); + } return released; } -inline void StreamPartHandshakeRequest::set_allocated_interleavenodeid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartHandshakeRequest::set_allocated_interleavenodeid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.interleavenodeid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.interleavenodeid_.IsDefault()) { - _impl_.interleavenodeid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.interleavenodeid_.IsDefault()) { + _impl_.interleavenodeid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamPartHandshakeRequest.interleaveNodeId) } @@ -6262,8 +6492,10 @@ inline void StreamPartHandshakeRequest::set_allocated_interleavenodeid(std::stri // bool accepted = 1; inline void StreamPartHandshakeResponse::clear_accepted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline bool StreamPartHandshakeResponse::accepted() const { // @@protoc_insertion_point(field_get:StreamPartHandshakeResponse.accepted) @@ -6271,79 +6503,91 @@ inline bool StreamPartHandshakeResponse::accepted() const { } inline void StreamPartHandshakeResponse::set_accepted(bool value) { _internal_set_accepted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:StreamPartHandshakeResponse.accepted) } inline bool StreamPartHandshakeResponse::_internal_accepted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.accepted_; } inline void StreamPartHandshakeResponse::_internal_set_accepted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = value; } // string requestId = 2; inline void StreamPartHandshakeResponse::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& StreamPartHandshakeResponse::requestid() const +inline const ::std::string& StreamPartHandshakeResponse::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartHandshakeResponse.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeResponse::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StreamPartHandshakeResponse::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamPartHandshakeResponse.requestId) } -inline std::string* StreamPartHandshakeResponse::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeResponse::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:StreamPartHandshakeResponse.requestId) return _s; } -inline const std::string& StreamPartHandshakeResponse::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamPartHandshakeResponse::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void StreamPartHandshakeResponse::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StreamPartHandshakeResponse::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* StreamPartHandshakeResponse::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StreamPartHandshakeResponse::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* StreamPartHandshakeResponse::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamPartHandshakeResponse::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartHandshakeResponse.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void StreamPartHandshakeResponse::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartHandshakeResponse::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamPartHandshakeResponse.requestId) } // optional .dht.PeerDescriptor interleaveTargetDescriptor = 3; inline bool StreamPartHandshakeResponse::has_interleavetargetdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); PROTOBUF_ASSUME(!value || _impl_.interleavetargetdescriptor_ != nullptr); return value; } inline const ::dht::PeerDescriptor& StreamPartHandshakeResponse::_internal_interleavetargetdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.interleavetargetdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -6351,76 +6595,78 @@ inline const ::dht::PeerDescriptor& StreamPartHandshakeResponse::interleavetarge // @@protoc_insertion_point(field_get:StreamPartHandshakeResponse.interleaveTargetDescriptor) return _internal_interleavetargetdescriptor(); } -inline void StreamPartHandshakeResponse::unsafe_arena_set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartHandshakeResponse::unsafe_arena_set_allocated_interleavetargetdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.interleavetargetdescriptor_); } _impl_.interleavetargetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:StreamPartHandshakeResponse.interleaveTargetDescriptor) } -inline ::dht::PeerDescriptor* StreamPartHandshakeResponse::release_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE StreamPartHandshakeResponse::release_interleavetargetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* released = _impl_.interleavetargetdescriptor_; _impl_.interleavetargetdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* StreamPartHandshakeResponse::unsafe_arena_release_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE StreamPartHandshakeResponse::unsafe_arena_release_interleavetargetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartHandshakeResponse.interleaveTargetDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* temp = _impl_.interleavetargetdescriptor_; _impl_.interleavetargetdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* StreamPartHandshakeResponse::_internal_mutable_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL StreamPartHandshakeResponse::_internal_mutable_interleavetargetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.interleavetargetdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.interleavetargetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.interleavetargetdescriptor_; } -inline ::dht::PeerDescriptor* StreamPartHandshakeResponse::mutable_interleavetargetdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL StreamPartHandshakeResponse::mutable_interleavetargetdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); ::dht::PeerDescriptor* _msg = _internal_mutable_interleavetargetdescriptor(); // @@protoc_insertion_point(field_mutable:StreamPartHandshakeResponse.interleaveTargetDescriptor) return _msg; } -inline void StreamPartHandshakeResponse::set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value) { +inline void StreamPartHandshakeResponse::set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.interleavetargetdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.interleavetargetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -6433,12 +6679,12 @@ inline void StreamPartHandshakeResponse::set_allocated_interleavetargetdescripto // .dht.PeerDescriptor interleaveTargetDescriptor = 1; inline bool InterleaveRequest::has_interleavetargetdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); PROTOBUF_ASSUME(!value || _impl_.interleavetargetdescriptor_ != nullptr); return value; } inline const ::dht::PeerDescriptor& InterleaveRequest::_internal_interleavetargetdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.interleavetargetdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -6446,76 +6692,78 @@ inline const ::dht::PeerDescriptor& InterleaveRequest::interleavetargetdescripto // @@protoc_insertion_point(field_get:InterleaveRequest.interleaveTargetDescriptor) return _internal_interleavetargetdescriptor(); } -inline void InterleaveRequest::unsafe_arena_set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void InterleaveRequest::unsafe_arena_set_allocated_interleavetargetdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.interleavetargetdescriptor_); } _impl_.interleavetargetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:InterleaveRequest.interleaveTargetDescriptor) } -inline ::dht::PeerDescriptor* InterleaveRequest::release_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE InterleaveRequest::release_interleavetargetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::PeerDescriptor* released = _impl_.interleavetargetdescriptor_; _impl_.interleavetargetdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* InterleaveRequest::unsafe_arena_release_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE InterleaveRequest::unsafe_arena_release_interleavetargetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:InterleaveRequest.interleaveTargetDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::PeerDescriptor* temp = _impl_.interleavetargetdescriptor_; _impl_.interleavetargetdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* InterleaveRequest::_internal_mutable_interleavetargetdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL InterleaveRequest::_internal_mutable_interleavetargetdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.interleavetargetdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.interleavetargetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.interleavetargetdescriptor_; } -inline ::dht::PeerDescriptor* InterleaveRequest::mutable_interleavetargetdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL InterleaveRequest::mutable_interleavetargetdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::dht::PeerDescriptor* _msg = _internal_mutable_interleavetargetdescriptor(); // @@protoc_insertion_point(field_mutable:InterleaveRequest.interleaveTargetDescriptor) return _msg; } -inline void InterleaveRequest::set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* value) { +inline void InterleaveRequest::set_allocated_interleavetargetdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.interleavetargetdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.interleavetargetdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -6528,8 +6776,10 @@ inline void InterleaveRequest::set_allocated_interleavetargetdescriptor(::dht::P // bool accepted = 1; inline void InterleaveResponse::clear_accepted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline bool InterleaveResponse::accepted() const { // @@protoc_insertion_point(field_get:InterleaveResponse.accepted) @@ -6537,15 +6787,15 @@ inline bool InterleaveResponse::accepted() const { } inline void InterleaveResponse::set_accepted(bool value) { _internal_set_accepted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:InterleaveResponse.accepted) } inline bool InterleaveResponse::_internal_accepted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.accepted_; } inline void InterleaveResponse::_internal_set_accepted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = value; } @@ -6555,61 +6805,75 @@ inline void InterleaveResponse::_internal_set_accepted(bool value) { // string streamPartId = 1; inline void LeaveStreamPartNotice::clear_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& LeaveStreamPartNotice::streampartid() const +inline const ::std::string& LeaveStreamPartNotice::streampartid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:LeaveStreamPartNotice.streamPartId) return _internal_streampartid(); } template -inline PROTOBUF_ALWAYS_INLINE void LeaveStreamPartNotice::set_streampartid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void LeaveStreamPartNotice::set_streampartid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.streampartid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:LeaveStreamPartNotice.streamPartId) } -inline std::string* LeaveStreamPartNotice::mutable_streampartid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_streampartid(); +inline ::std::string* PROTOBUF_NONNULL LeaveStreamPartNotice::mutable_streampartid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_streampartid(); // @@protoc_insertion_point(field_mutable:LeaveStreamPartNotice.streamPartId) return _s; } -inline const std::string& LeaveStreamPartNotice::_internal_streampartid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& LeaveStreamPartNotice::_internal_streampartid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.streampartid_.Get(); } -inline void LeaveStreamPartNotice::_internal_set_streampartid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void LeaveStreamPartNotice::_internal_set_streampartid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartid_.Set(value, GetArena()); } -inline std::string* LeaveStreamPartNotice::_internal_mutable_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL LeaveStreamPartNotice::_internal_mutable_streampartid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.streampartid_.Mutable( GetArena()); } -inline std::string* LeaveStreamPartNotice::release_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE LeaveStreamPartNotice::release_streampartid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:LeaveStreamPartNotice.streamPartId) - return _impl_.streampartid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.streampartid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.streampartid_.Set("", GetArena()); + } + return released; } -inline void LeaveStreamPartNotice::set_allocated_streampartid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void LeaveStreamPartNotice::set_allocated_streampartid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.streampartid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streampartid_.IsDefault()) { - _impl_.streampartid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.streampartid_.IsDefault()) { + _impl_.streampartid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:LeaveStreamPartNotice.streamPartId) } // bool isEntryPoint = 2; inline void LeaveStreamPartNotice::clear_isentrypoint() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.isentrypoint_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline bool LeaveStreamPartNotice::isentrypoint() const { // @@protoc_insertion_point(field_get:LeaveStreamPartNotice.isEntryPoint) @@ -6617,15 +6881,15 @@ inline bool LeaveStreamPartNotice::isentrypoint() const { } inline void LeaveStreamPartNotice::set_isentrypoint(bool value) { _internal_set_isentrypoint(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:LeaveStreamPartNotice.isEntryPoint) } inline bool LeaveStreamPartNotice::_internal_isentrypoint() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.isentrypoint_; } inline void LeaveStreamPartNotice::_internal_set_isentrypoint(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.isentrypoint_ = value; } @@ -6635,61 +6899,75 @@ inline void LeaveStreamPartNotice::_internal_set_isentrypoint(bool value) { // string streamPartId = 1; inline void NeighborUpdate::clear_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& NeighborUpdate::streampartid() const +inline const ::std::string& NeighborUpdate::streampartid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:NeighborUpdate.streamPartId) return _internal_streampartid(); } template -inline PROTOBUF_ALWAYS_INLINE void NeighborUpdate::set_streampartid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void NeighborUpdate::set_streampartid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.streampartid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:NeighborUpdate.streamPartId) } -inline std::string* NeighborUpdate::mutable_streampartid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_streampartid(); +inline ::std::string* PROTOBUF_NONNULL NeighborUpdate::mutable_streampartid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_streampartid(); // @@protoc_insertion_point(field_mutable:NeighborUpdate.streamPartId) return _s; } -inline const std::string& NeighborUpdate::_internal_streampartid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& NeighborUpdate::_internal_streampartid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.streampartid_.Get(); } -inline void NeighborUpdate::_internal_set_streampartid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void NeighborUpdate::_internal_set_streampartid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartid_.Set(value, GetArena()); } -inline std::string* NeighborUpdate::_internal_mutable_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL NeighborUpdate::_internal_mutable_streampartid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.streampartid_.Mutable( GetArena()); } -inline std::string* NeighborUpdate::release_streampartid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE NeighborUpdate::release_streampartid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:NeighborUpdate.streamPartId) - return _impl_.streampartid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.streampartid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.streampartid_.Set("", GetArena()); + } + return released; } -inline void NeighborUpdate::set_allocated_streampartid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void NeighborUpdate::set_allocated_streampartid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.streampartid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streampartid_.IsDefault()) { - _impl_.streampartid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.streampartid_.IsDefault()) { + _impl_.streampartid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:NeighborUpdate.streamPartId) } // bool removeMe = 2; inline void NeighborUpdate::clear_removeme() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.removeme_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } inline bool NeighborUpdate::removeme() const { // @@protoc_insertion_point(field_get:NeighborUpdate.removeMe) @@ -6697,15 +6975,15 @@ inline bool NeighborUpdate::removeme() const { } inline void NeighborUpdate::set_removeme(bool value) { _internal_set_removeme(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); // @@protoc_insertion_point(field_set:NeighborUpdate.removeMe) } inline bool NeighborUpdate::_internal_removeme() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.removeme_; } inline void NeighborUpdate::_internal_set_removeme(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.removeme_ = value; } @@ -6716,15 +6994,16 @@ inline int NeighborUpdate::_internal_neighbordescriptors_size() const { inline int NeighborUpdate::neighbordescriptors_size() const { return _internal_neighbordescriptors_size(); } -inline ::dht::PeerDescriptor* NeighborUpdate::mutable_neighbordescriptors(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL NeighborUpdate::mutable_neighbordescriptors(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:NeighborUpdate.neighborDescriptors) return _internal_mutable_neighbordescriptors()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* NeighborUpdate::mutable_neighbordescriptors() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL NeighborUpdate::mutable_neighbordescriptors() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:NeighborUpdate.neighborDescriptors) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_neighbordescriptors(); } inline const ::dht::PeerDescriptor& NeighborUpdate::neighbordescriptors(int index) const @@ -6732,9 +7011,13 @@ inline const ::dht::PeerDescriptor& NeighborUpdate::neighbordescriptors(int inde // @@protoc_insertion_point(field_get:NeighborUpdate.neighborDescriptors) return _internal_neighbordescriptors().Get(index); } -inline ::dht::PeerDescriptor* NeighborUpdate::add_neighbordescriptors() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_neighbordescriptors()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL NeighborUpdate::add_neighbordescriptors() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_neighbordescriptors()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:NeighborUpdate.neighborDescriptors) return _add; } @@ -6745,12 +7028,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Neighb } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& NeighborUpdate::_internal_neighbordescriptors() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.neighbordescriptors_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL NeighborUpdate::_internal_mutable_neighbordescriptors() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.neighbordescriptors_; } @@ -6760,8 +7043,10 @@ NeighborUpdate::_internal_mutable_neighbordescriptors() { // .ProxyDirection direction = 1; inline void ProxyConnectionRequest::clear_direction() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.direction_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } inline ::ProxyDirection ProxyConnectionRequest::direction() const { // @@protoc_insertion_point(field_get:ProxyConnectionRequest.direction) @@ -6769,68 +7054,80 @@ inline ::ProxyDirection ProxyConnectionRequest::direction() const { } inline void ProxyConnectionRequest::set_direction(::ProxyDirection value) { _internal_set_direction(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_set:ProxyConnectionRequest.direction) } inline ::ProxyDirection ProxyConnectionRequest::_internal_direction() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::ProxyDirection>(_impl_.direction_); } inline void ProxyConnectionRequest::_internal_set_direction(::ProxyDirection value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.direction_ = value; } // bytes userId = 2; inline void ProxyConnectionRequest::clear_userid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.userid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& ProxyConnectionRequest::userid() const +inline const ::std::string& ProxyConnectionRequest::userid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:ProxyConnectionRequest.userId) return _internal_userid(); } template -inline PROTOBUF_ALWAYS_INLINE void ProxyConnectionRequest::set_userid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void ProxyConnectionRequest::set_userid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.userid_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:ProxyConnectionRequest.userId) } -inline std::string* ProxyConnectionRequest::mutable_userid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_userid(); +inline ::std::string* PROTOBUF_NONNULL ProxyConnectionRequest::mutable_userid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_userid(); // @@protoc_insertion_point(field_mutable:ProxyConnectionRequest.userId) return _s; } -inline const std::string& ProxyConnectionRequest::_internal_userid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& ProxyConnectionRequest::_internal_userid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.userid_.Get(); } -inline void ProxyConnectionRequest::_internal_set_userid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void ProxyConnectionRequest::_internal_set_userid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.userid_.Set(value, GetArena()); } -inline std::string* ProxyConnectionRequest::_internal_mutable_userid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL ProxyConnectionRequest::_internal_mutable_userid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.userid_.Mutable( GetArena()); } -inline std::string* ProxyConnectionRequest::release_userid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE ProxyConnectionRequest::release_userid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:ProxyConnectionRequest.userId) - return _impl_.userid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.userid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.userid_.Set("", GetArena()); + } + return released; } -inline void ProxyConnectionRequest::set_allocated_userid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void ProxyConnectionRequest::set_allocated_userid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.userid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userid_.IsDefault()) { - _impl_.userid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.userid_.IsDefault()) { + _impl_.userid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:ProxyConnectionRequest.userId) } @@ -6840,8 +7137,10 @@ inline void ProxyConnectionRequest::set_allocated_userid(std::string* value) { // bool accepted = 1; inline void ProxyConnectionResponse::clear_accepted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline bool ProxyConnectionResponse::accepted() const { // @@protoc_insertion_point(field_get:ProxyConnectionResponse.accepted) @@ -6849,15 +7148,15 @@ inline bool ProxyConnectionResponse::accepted() const { } inline void ProxyConnectionResponse::set_accepted(bool value) { _internal_set_accepted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:ProxyConnectionResponse.accepted) } inline bool ProxyConnectionResponse::_internal_accepted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.accepted_; } inline void ProxyConnectionResponse::_internal_set_accepted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = value; } @@ -6871,8 +7170,10 @@ inline void ProxyConnectionResponse::_internal_set_accepted(bool value) { // bool accepted = 1; inline void TemporaryConnectionResponse::clear_accepted() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } inline bool TemporaryConnectionResponse::accepted() const { // @@protoc_insertion_point(field_get:TemporaryConnectionResponse.accepted) @@ -6880,15 +7181,15 @@ inline bool TemporaryConnectionResponse::accepted() const { } inline void TemporaryConnectionResponse::set_accepted(bool value) { _internal_set_accepted(value); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_set:TemporaryConnectionResponse.accepted) } inline bool TemporaryConnectionResponse::_internal_accepted() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.accepted_; } inline void TemporaryConnectionResponse::_internal_set_accepted(bool value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.accepted_ = value; } @@ -6902,54 +7203,66 @@ inline void TemporaryConnectionResponse::_internal_set_accepted(bool value) { // string id = 1; inline void StreamPartitionInfo::clear_id() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& StreamPartitionInfo::id() const +inline const ::std::string& StreamPartitionInfo::id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:StreamPartitionInfo.id) return _internal_id(); } template -inline PROTOBUF_ALWAYS_INLINE void StreamPartitionInfo::set_id(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void StreamPartitionInfo::set_id(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.id_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:StreamPartitionInfo.id) } -inline std::string* StreamPartitionInfo::mutable_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_id(); +inline ::std::string* PROTOBUF_NONNULL StreamPartitionInfo::mutable_id() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_id(); // @@protoc_insertion_point(field_mutable:StreamPartitionInfo.id) return _s; } -inline const std::string& StreamPartitionInfo::_internal_id() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& StreamPartitionInfo::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_.Get(); } -inline void StreamPartitionInfo::_internal_set_id(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void StreamPartitionInfo::_internal_set_id(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(value, GetArena()); } -inline std::string* StreamPartitionInfo::_internal_mutable_id() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL StreamPartitionInfo::_internal_mutable_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.id_.Mutable( GetArena()); } -inline std::string* StreamPartitionInfo::release_id() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE StreamPartitionInfo::release_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:StreamPartitionInfo.id) - return _impl_.id_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.id_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.id_.Set("", GetArena()); + } + return released; } -inline void StreamPartitionInfo::set_allocated_id(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void StreamPartitionInfo::set_allocated_id(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } _impl_.id_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:StreamPartitionInfo.id) } @@ -6960,15 +7273,16 @@ inline int StreamPartitionInfo::_internal_controllayerneighbors_size() const { inline int StreamPartitionInfo::controllayerneighbors_size() const { return _internal_controllayerneighbors_size(); } -inline ::dht::PeerDescriptor* StreamPartitionInfo::mutable_controllayerneighbors(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL StreamPartitionInfo::mutable_controllayerneighbors(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:StreamPartitionInfo.controlLayerNeighbors) return _internal_mutable_controllayerneighbors()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* StreamPartitionInfo::mutable_controllayerneighbors() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL StreamPartitionInfo::mutable_controllayerneighbors() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:StreamPartitionInfo.controlLayerNeighbors) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_controllayerneighbors(); } inline const ::dht::PeerDescriptor& StreamPartitionInfo::controllayerneighbors(int index) const @@ -6976,9 +7290,13 @@ inline const ::dht::PeerDescriptor& StreamPartitionInfo::controllayerneighbors(i // @@protoc_insertion_point(field_get:StreamPartitionInfo.controlLayerNeighbors) return _internal_controllayerneighbors().Get(index); } -inline ::dht::PeerDescriptor* StreamPartitionInfo::add_controllayerneighbors() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_controllayerneighbors()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL StreamPartitionInfo::add_controllayerneighbors() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_controllayerneighbors()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:StreamPartitionInfo.controlLayerNeighbors) return _add; } @@ -6989,12 +7307,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Stream } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& StreamPartitionInfo::_internal_controllayerneighbors() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.controllayerneighbors_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL StreamPartitionInfo::_internal_mutable_controllayerneighbors() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.controllayerneighbors_; } @@ -7005,15 +7323,16 @@ inline int StreamPartitionInfo::_internal_contentdeliverylayerneighbors_size() c inline int StreamPartitionInfo::contentdeliverylayerneighbors_size() const { return _internal_contentdeliverylayerneighbors_size(); } -inline ::dht::PeerDescriptor* StreamPartitionInfo::mutable_contentdeliverylayerneighbors(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL StreamPartitionInfo::mutable_contentdeliverylayerneighbors(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:StreamPartitionInfo.contentDeliveryLayerNeighbors) return _internal_mutable_contentdeliverylayerneighbors()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* StreamPartitionInfo::mutable_contentdeliverylayerneighbors() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL StreamPartitionInfo::mutable_contentdeliverylayerneighbors() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:StreamPartitionInfo.contentDeliveryLayerNeighbors) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_contentdeliverylayerneighbors(); } inline const ::dht::PeerDescriptor& StreamPartitionInfo::contentdeliverylayerneighbors(int index) const @@ -7021,9 +7340,13 @@ inline const ::dht::PeerDescriptor& StreamPartitionInfo::contentdeliverylayernei // @@protoc_insertion_point(field_get:StreamPartitionInfo.contentDeliveryLayerNeighbors) return _internal_contentdeliverylayerneighbors().Get(index); } -inline ::dht::PeerDescriptor* StreamPartitionInfo::add_contentdeliverylayerneighbors() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_contentdeliverylayerneighbors()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL StreamPartitionInfo::add_contentdeliverylayerneighbors() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_contentdeliverylayerneighbors()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:StreamPartitionInfo.contentDeliveryLayerNeighbors) return _add; } @@ -7034,12 +7357,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Stream } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& StreamPartitionInfo::_internal_contentdeliverylayerneighbors() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.contentdeliverylayerneighbors_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL StreamPartitionInfo::_internal_mutable_contentdeliverylayerneighbors() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.contentdeliverylayerneighbors_; } @@ -7054,15 +7377,16 @@ inline int ControlLayerInfo::_internal_neighbors_size() const { inline int ControlLayerInfo::neighbors_size() const { return _internal_neighbors_size(); } -inline ::dht::PeerDescriptor* ControlLayerInfo::mutable_neighbors(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ControlLayerInfo::mutable_neighbors(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:ControlLayerInfo.neighbors) return _internal_mutable_neighbors()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ControlLayerInfo::mutable_neighbors() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ControlLayerInfo::mutable_neighbors() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:ControlLayerInfo.neighbors) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_neighbors(); } inline const ::dht::PeerDescriptor& ControlLayerInfo::neighbors(int index) const @@ -7070,9 +7394,13 @@ inline const ::dht::PeerDescriptor& ControlLayerInfo::neighbors(int index) const // @@protoc_insertion_point(field_get:ControlLayerInfo.neighbors) return _internal_neighbors().Get(index); } -inline ::dht::PeerDescriptor* ControlLayerInfo::add_neighbors() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_neighbors()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ControlLayerInfo::add_neighbors() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_neighbors()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:ControlLayerInfo.neighbors) return _add; } @@ -7083,12 +7411,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Contro } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ControlLayerInfo::_internal_neighbors() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.neighbors_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ControlLayerInfo::_internal_mutable_neighbors() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.neighbors_; } @@ -7099,15 +7427,16 @@ inline int ControlLayerInfo::_internal_connections_size() const { inline int ControlLayerInfo::connections_size() const { return _internal_connections_size(); } -inline ::dht::PeerDescriptor* ControlLayerInfo::mutable_connections(int index) +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ControlLayerInfo::mutable_connections(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:ControlLayerInfo.connections) return _internal_mutable_connections()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* ControlLayerInfo::mutable_connections() +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ControlLayerInfo::mutable_connections() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_mutable_list:ControlLayerInfo.connections) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_connections(); } inline const ::dht::PeerDescriptor& ControlLayerInfo::connections(int index) const @@ -7115,9 +7444,13 @@ inline const ::dht::PeerDescriptor& ControlLayerInfo::connections(int index) con // @@protoc_insertion_point(field_get:ControlLayerInfo.connections) return _internal_connections().Get(index); } -inline ::dht::PeerDescriptor* ControlLayerInfo::add_connections() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::dht::PeerDescriptor* _add = _internal_mutable_connections()->Add(); +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL ControlLayerInfo::add_connections() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dht::PeerDescriptor* _add = + _internal_mutable_connections()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U); // @@protoc_insertion_point(field_add:ControlLayerInfo.connections) return _add; } @@ -7128,12 +7461,12 @@ inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& Contro } inline const ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>& ControlLayerInfo::_internal_connections() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.connections_; } -inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* +inline ::google::protobuf::RepeatedPtrField<::dht::PeerDescriptor>* PROTOBUF_NONNULL ControlLayerInfo::_internal_mutable_connections() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.connections_; } @@ -7147,12 +7480,12 @@ ControlLayerInfo::_internal_mutable_connections() { // .dht.PeerDescriptor peerDescriptor = 1; inline bool NodeInfoResponse::has_peerdescriptor() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.peerdescriptor_ != nullptr); return value; } inline const ::dht::PeerDescriptor& NodeInfoResponse::_internal_peerdescriptor() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::dht::PeerDescriptor* p = _impl_.peerdescriptor_; return p != nullptr ? *p : reinterpret_cast(::dht::_PeerDescriptor_default_instance_); } @@ -7160,76 +7493,78 @@ inline const ::dht::PeerDescriptor& NodeInfoResponse::peerdescriptor() const ABS // @@protoc_insertion_point(field_get:NodeInfoResponse.peerDescriptor) return _internal_peerdescriptor(); } -inline void NodeInfoResponse::unsafe_arena_set_allocated_peerdescriptor(::dht::PeerDescriptor* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void NodeInfoResponse::unsafe_arena_set_allocated_peerdescriptor( + ::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peerdescriptor_); } _impl_.peerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NodeInfoResponse.peerDescriptor) } -inline ::dht::PeerDescriptor* NodeInfoResponse::release_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE NodeInfoResponse::release_peerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* released = _impl_.peerdescriptor_; _impl_.peerdescriptor_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::dht::PeerDescriptor* NodeInfoResponse::unsafe_arena_release_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::dht::PeerDescriptor* PROTOBUF_NULLABLE NodeInfoResponse::unsafe_arena_release_peerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:NodeInfoResponse.peerDescriptor) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* temp = _impl_.peerdescriptor_; _impl_.peerdescriptor_ = nullptr; return temp; } -inline ::dht::PeerDescriptor* NodeInfoResponse::_internal_mutable_peerdescriptor() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL NodeInfoResponse::_internal_mutable_peerdescriptor() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peerdescriptor_ == nullptr) { - auto* p = CreateMaybeMessage<::dht::PeerDescriptor>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::dht::PeerDescriptor>(GetArena()); _impl_.peerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(p); } return _impl_.peerdescriptor_; } -inline ::dht::PeerDescriptor* NodeInfoResponse::mutable_peerdescriptor() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::dht::PeerDescriptor* PROTOBUF_NONNULL NodeInfoResponse::mutable_peerdescriptor() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::dht::PeerDescriptor* _msg = _internal_mutable_peerdescriptor(); // @@protoc_insertion_point(field_mutable:NodeInfoResponse.peerDescriptor) return _msg; } -inline void NodeInfoResponse::set_allocated_peerdescriptor(::dht::PeerDescriptor* value) { +inline void NodeInfoResponse::set_allocated_peerdescriptor(::dht::PeerDescriptor* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peerdescriptor_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.peerdescriptor_ = reinterpret_cast<::dht::PeerDescriptor*>(value); @@ -7244,18 +7579,21 @@ inline int NodeInfoResponse::streampartitions_size() const { return _internal_streampartitions_size(); } inline void NodeInfoResponse::clear_streampartitions() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.streampartitions_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline ::StreamPartitionInfo* NodeInfoResponse::mutable_streampartitions(int index) +inline ::StreamPartitionInfo* PROTOBUF_NONNULL NodeInfoResponse::mutable_streampartitions(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:NodeInfoResponse.streamPartitions) return _internal_mutable_streampartitions()->Mutable(index); } -inline ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* NodeInfoResponse::mutable_streampartitions() +inline ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* PROTOBUF_NONNULL NodeInfoResponse::mutable_streampartitions() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_mutable_list:NodeInfoResponse.streamPartitions) - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_streampartitions(); } inline const ::StreamPartitionInfo& NodeInfoResponse::streampartitions(int index) const @@ -7263,9 +7601,13 @@ inline const ::StreamPartitionInfo& NodeInfoResponse::streampartitions(int index // @@protoc_insertion_point(field_get:NodeInfoResponse.streamPartitions) return _internal_streampartitions().Get(index); } -inline ::StreamPartitionInfo* NodeInfoResponse::add_streampartitions() ABSL_ATTRIBUTE_LIFETIME_BOUND { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ::StreamPartitionInfo* _add = _internal_mutable_streampartitions()->Add(); +inline ::StreamPartitionInfo* PROTOBUF_NONNULL NodeInfoResponse::add_streampartitions() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::StreamPartitionInfo* _add = + _internal_mutable_streampartitions()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); // @@protoc_insertion_point(field_add:NodeInfoResponse.streamPartitions) return _add; } @@ -7276,28 +7618,29 @@ inline const ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>& NodeIn } inline const ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>& NodeInfoResponse::_internal_streampartitions() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.streampartitions_; } -inline ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* +inline ::google::protobuf::RepeatedPtrField<::StreamPartitionInfo>* PROTOBUF_NONNULL NodeInfoResponse::_internal_mutable_streampartitions() { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.streampartitions_; } // optional .ControlLayerInfo controlLayer = 3; inline bool NodeInfoResponse::has_controllayer() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); PROTOBUF_ASSUME(!value || _impl_.controllayer_ != nullptr); return value; } inline void NodeInfoResponse::clear_controllayer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.controllayer_ != nullptr) _impl_.controllayer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } inline const ::ControlLayerInfo& NodeInfoResponse::_internal_controllayer() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::ControlLayerInfo* p = _impl_.controllayer_; return p != nullptr ? *p : reinterpret_cast(::_ControlLayerInfo_default_instance_); } @@ -7305,76 +7648,78 @@ inline const ::ControlLayerInfo& NodeInfoResponse::controllayer() const ABSL_ATT // @@protoc_insertion_point(field_get:NodeInfoResponse.controlLayer) return _internal_controllayer(); } -inline void NodeInfoResponse::unsafe_arena_set_allocated_controllayer(::ControlLayerInfo* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void NodeInfoResponse::unsafe_arena_set_allocated_controllayer( + ::ControlLayerInfo* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.controllayer_); } _impl_.controllayer_ = reinterpret_cast<::ControlLayerInfo*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NodeInfoResponse.controlLayer) } -inline ::ControlLayerInfo* NodeInfoResponse::release_controllayer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ControlLayerInfo* PROTOBUF_NULLABLE NodeInfoResponse::release_controllayer() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::ControlLayerInfo* released = _impl_.controllayer_; _impl_.controllayer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::ControlLayerInfo* NodeInfoResponse::unsafe_arena_release_controllayer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::ControlLayerInfo* PROTOBUF_NULLABLE NodeInfoResponse::unsafe_arena_release_controllayer() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:NodeInfoResponse.controlLayer) - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); ::ControlLayerInfo* temp = _impl_.controllayer_; _impl_.controllayer_ = nullptr; return temp; } -inline ::ControlLayerInfo* NodeInfoResponse::_internal_mutable_controllayer() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::ControlLayerInfo* PROTOBUF_NONNULL NodeInfoResponse::_internal_mutable_controllayer() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.controllayer_ == nullptr) { - auto* p = CreateMaybeMessage<::ControlLayerInfo>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::ControlLayerInfo>(GetArena()); _impl_.controllayer_ = reinterpret_cast<::ControlLayerInfo*>(p); } return _impl_.controllayer_; } -inline ::ControlLayerInfo* NodeInfoResponse::mutable_controllayer() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::ControlLayerInfo* PROTOBUF_NONNULL NodeInfoResponse::mutable_controllayer() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); ::ControlLayerInfo* _msg = _internal_mutable_controllayer(); // @@protoc_insertion_point(field_mutable:NodeInfoResponse.controlLayer) return _msg; } -inline void NodeInfoResponse::set_allocated_controllayer(::ControlLayerInfo* value) { +inline void NodeInfoResponse::set_allocated_controllayer(::ControlLayerInfo* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::ControlLayerInfo*>(_impl_.controllayer_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.controllayer_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::ControlLayerInfo*>(value)->GetArena(); + ::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; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.controllayer_ = reinterpret_cast<::ControlLayerInfo*>(value); @@ -7383,54 +7728,66 @@ inline void NodeInfoResponse::set_allocated_controllayer(::ControlLayerInfo* val // string version = 4; inline void NodeInfoResponse::clear_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& NodeInfoResponse::version() const +inline const ::std::string& NodeInfoResponse::version() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:NodeInfoResponse.version) return _internal_version(); } template -inline PROTOBUF_ALWAYS_INLINE void NodeInfoResponse::set_version(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void NodeInfoResponse::set_version(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.version_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:NodeInfoResponse.version) } -inline std::string* NodeInfoResponse::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_version(); +inline ::std::string* PROTOBUF_NONNULL NodeInfoResponse::mutable_version() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_version(); // @@protoc_insertion_point(field_mutable:NodeInfoResponse.version) return _s; } -inline const std::string& NodeInfoResponse::_internal_version() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& NodeInfoResponse::_internal_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_.Get(); } -inline void NodeInfoResponse::_internal_set_version(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void NodeInfoResponse::_internal_set_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_.Set(value, GetArena()); } -inline std::string* NodeInfoResponse::_internal_mutable_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL NodeInfoResponse::_internal_mutable_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.version_.Mutable( GetArena()); } -inline std::string* NodeInfoResponse::release_version() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE NodeInfoResponse::release_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:NodeInfoResponse.version) - return _impl_.version_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.version_.Set("", GetArena()); + } + return released; } -inline void NodeInfoResponse::set_allocated_version(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void NodeInfoResponse::set_allocated_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } _impl_.version_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:NodeInfoResponse.version) } @@ -7447,25 +7804,25 @@ namespace protobuf { template <> struct is_proto_enum<::ContentType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::ContentType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::ContentType>() { return ::ContentType_descriptor(); } template <> struct is_proto_enum<::EncryptionType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::EncryptionType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::EncryptionType>() { return ::EncryptionType_descriptor(); } template <> struct is_proto_enum<::SignatureType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::SignatureType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::SignatureType>() { return ::SignatureType_descriptor(); } template <> struct is_proto_enum<::ProxyDirection> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::ProxyDirection>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::ProxyDirection>() { return ::ProxyDirection_descriptor(); } @@ -7476,4 +7833,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::ProxyDirection>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_2epb_2eh +#endif // packages_2fnetwork_2fprotos_2fNetworkRpc_2eproto_2epb_2eh diff --git a/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc b/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc index 842c2e07..b8f9719f 100644 --- a/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc +++ b/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.cc @@ -1,11 +1,16 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/proto-rpc/protos/ProtoRpc.proto +// Protobuf C++ Version: 6.33.4 #include "packages/proto-rpc/protos/ProtoRpc.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" @@ -18,9 +23,16 @@ PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; namespace protorpc { - template -PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::_pbi::ConstantInitialized) {} +template +PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : RpcMessage_HeaderEntry_DoNotUse::MapEntry(RpcMessage_HeaderEntry_DoNotUse_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : RpcMessage_HeaderEntry_DoNotUse::MapEntry() { +} +#endif // PROTOBUF_CUSTOM_VTABLE struct RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal { PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal() {} @@ -35,7 +47,6 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT inline constexpr RpcMessage::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - header_{}, requestid_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), @@ -49,11 +60,18 @@ inline constexpr RpcMessage::Impl_::Impl_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), body_{nullptr}, - errortype_{static_cast< ::protorpc::RpcErrorType >(0)} {} + errortype_{static_cast< ::protorpc::RpcErrorType >(0)}, + header_{} {} template PROTOBUF_CONSTEXPR RpcMessage::RpcMessage(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(RpcMessage_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct RpcMessageDefaultTypeInternal { PROTOBUF_CONSTEXPR RpcMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RpcMessageDefaultTypeInternal() {} @@ -72,7 +90,13 @@ inline constexpr Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( template PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::_pbi::ConstantInitialized) - : _impl_(::_pbi::ConstantInitialized()) {} +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal { PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal() {} @@ -84,71 +108,57 @@ struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal _Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_; } // namespace protorpc -static ::_pb::Metadata file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[3]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]; -static constexpr const ::_pb::ServiceDescriptor** +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = nullptr; -const ::uint32_t TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( - protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _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(::protorpc::RpcMessage_HeaderEntry_DoNotUse, key_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, value_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _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(::protorpc::RpcMessage, _impl_.header_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.requestid_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errortype_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorclassname_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorcode_), - PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errormessage_), - ~0u, - 3, - ~0u, - 4, - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _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(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), - 0, +const ::uint32_t + TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage_HeaderEntry_DoNotUse, _impl_.value_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_._has_bits_), + 10, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.header_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.requestid_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errortype_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorclassname_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errorcode_), + PROTOBUF_FIELD_OFFSET(::protorpc::RpcMessage, _impl_.errormessage_), + 6, + 4, + 0, + 5, + 1, + 2, + 3, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), + 0, }; static const ::_pbi::MigrationSchema - schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 10, -1, sizeof(::protorpc::RpcMessage_HeaderEntry_DoNotUse)}, - {12, 27, -1, sizeof(::protorpc::RpcMessage)}, - {34, 43, -1, sizeof(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq)}, + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::protorpc::RpcMessage_HeaderEntry_DoNotUse)}, + {7, sizeof(::protorpc::RpcMessage)}, + {24, sizeof(::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq)}, }; - -static const ::_pb::Message* const file_default_instances[] = { +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::protorpc::_RpcMessage_HeaderEntry_DoNotUse_default_instance_._instance, &::protorpc::_RpcMessage_default_instance_._instance, &::protorpc::_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_._instance, }; -const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { "\n(packages/proto-rpc/protos/ProtoRpc.pro" "to\022\010protorpc\032\033google/protobuf/empty.prot" "o\032\031google/protobuf/any.proto\"\344\002\n\nRpcMess" @@ -167,13 +177,13 @@ const char descriptor_table_protodef_packages_2fproto_2drpc_2fprotos_2fProtoRpc_ "UNKNOWN_RPC_METHOD\020\002\022\020\n\014CLIENT_ERROR\020\003\022\020" "\n\014SERVER_ERROR\020\004B\002H\002b\006proto3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_deps[2] = - { +static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const + descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::absl::once_flag descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = { +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto = { false, false, 668, @@ -186,127 +196,185 @@ const ::_pbi::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2 schemas, file_default_instances, TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto::offsets, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, file_level_service_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, }; - -// This function exists to be marked as weak. -// It can significantly speed up compilation by breaking up LLVM's SCC -// in the .pb.cc translation units. Large translation units see a -// reduction of more than 35% of walltime for optimized builds. Without -// the weak attribute all the messages in the file, including all the -// vtables and everything they use become part of the same SCC through -// a cycle like: -// GetMetadata -> descriptor table -> default instances -> -// vtables -> GetMetadata -// By adding a weak function here we break the connection from the -// individual vtables back into the descriptor table. -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter() { - return &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; -} -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 -static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto); namespace protorpc { -const ::google::protobuf::EnumDescriptor* RpcErrorType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcErrorType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto); return file_level_enum_descriptors_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t RpcErrorType_internal_data_[] = { 327680u, 0u, }; -bool RpcErrorType_IsValid(int value) { - return 0 <= value && value <= 4; -} // =================================================================== -RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() {} -RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* arena) - : SuperType(arena) {} -::google::protobuf::Metadata RpcMessage_HeaderEntry_DoNotUse::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[0]); +#if defined(PROTOBUF_CUSTOM_VTABLE) +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() + : SuperType(RpcMessage_HeaderEntry_DoNotUse_class_data_.base()) {} +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : SuperType(arena, RpcMessage_HeaderEntry_DoNotUse_class_data_.base()) {} +#else // PROTOBUF_CUSTOM_VTABLE +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse() : SuperType() {} +RpcMessage_HeaderEntry_DoNotUse::RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : SuperType(arena) {} +#endif // PROTOBUF_CUSTOM_VTABLE +inline void* PROTOBUF_NONNULL RpcMessage_HeaderEntry_DoNotUse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RpcMessage_HeaderEntry_DoNotUse(arena); +} +constexpr auto RpcMessage_HeaderEntry_DoNotUse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RpcMessage_HeaderEntry_DoNotUse), + alignof(RpcMessage_HeaderEntry_DoNotUse)); +} +constexpr auto RpcMessage_HeaderEntry_DoNotUse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RpcMessage_HeaderEntry_DoNotUse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcMessage_HeaderEntry_DoNotUse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcMessage_HeaderEntry_DoNotUse::SharedDtor, + static_cast(&RpcMessage_HeaderEntry_DoNotUse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_._cached_size_), + false, + }, + &RpcMessage_HeaderEntry_DoNotUse::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; } + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_ = + RpcMessage_HeaderEntry_DoNotUse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RpcMessage_HeaderEntry_DoNotUse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RpcMessage_HeaderEntry_DoNotUse_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RpcMessage_HeaderEntry_DoNotUse_class_data_.tc_table); + return RpcMessage_HeaderEntry_DoNotUse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 48, 2> +RpcMessage_HeaderEntry_DoNotUse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_._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 + RpcMessage_HeaderEntry_DoNotUse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::DiscardEverythingFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::RpcMessage_HeaderEntry_DoNotUse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string value = 2; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.value_)}}, + // string key = 1; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string key = 1; + {PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.key_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string value = 2; + {PROTOBUF_FIELD_OFFSET(RpcMessage_HeaderEntry_DoNotUse, _impl_.value_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\37\3\5\0\0\0\0\0" + "protorpc.RpcMessage.HeaderEntry" + "key" + "value" + }}, +}; // =================================================================== class RpcMessage::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._has_bits_); - static const ::google::protobuf::Any& body(const RpcMessage* msg); - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_errortype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_errorclassname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_errorcode(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_errormessage(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } + 8 * PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._has_bits_); }; -const ::google::protobuf::Any& RpcMessage::_Internal::body(const RpcMessage* msg) { - return *msg->_impl_.body_; -} void RpcMessage::clear_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ != nullptr) _impl_.body_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -RpcMessage::RpcMessage(::google::protobuf::Arena* arena) +RpcMessage::RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RpcMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:protorpc.RpcMessage) } -inline PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::protorpc::RpcMessage& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - header_{visibility, arena, from.header_}, requestid_(arena, from.requestid_), errorclassname_(arena, from.errorclassname_), errorcode_(arena, from.errorcode_), - errormessage_(arena, from.errormessage_) {} + errormessage_(arena, from.errormessage_), + header_{visibility, arena, from.header_} {} RpcMessage::RpcMessage( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RpcMessage& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RpcMessage_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE RpcMessage* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.body_ = (cached_has_bits & 0x00000008u) - ? CreateMaybeMessage<::google::protobuf::Any>(arena, *from._impl_.body_) + _impl_.body_ = (CheckHasBit(cached_has_bits, 0x00000010U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.body_) : nullptr; _impl_.errortype_ = from._impl_.errortype_; // @@protoc_insertion_point(copy_constructor:protorpc.RpcMessage) } -inline PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE RpcMessage::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - header_{visibility, arena}, requestid_(arena), errorclassname_(arena), errorcode_(arena), - errormessage_(arena) {} + errormessage_(arena), + header_{visibility, arena} {} -inline void RpcMessage::SharedCtor(::_pb::Arena* arena) { +inline void RpcMessage::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + + ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, body_), 0, offsetof(Impl_, errortype_) - @@ -315,110 +383,325 @@ inline void RpcMessage::SharedCtor(::_pb::Arena* arena) { } RpcMessage::~RpcMessage() { // @@protoc_insertion_point(destructor:protorpc.RpcMessage) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void RpcMessage::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - _impl_.requestid_.Destroy(); - _impl_.errorclassname_.Destroy(); - _impl_.errorcode_.Destroy(); - _impl_.errormessage_.Destroy(); - delete _impl_.body_; - _impl_.~Impl_(); +inline void RpcMessage::SharedDtor(MessageLite& self) { + RpcMessage& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.requestid_.Destroy(); + this_._impl_.errorclassname_.Destroy(); + this_._impl_.errorcode_.Destroy(); + this_._impl_.errormessage_.Destroy(); + delete this_._impl_.body_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RpcMessage::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RpcMessage(arena); } +constexpr auto RpcMessage::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.header_) + + decltype(RpcMessage::_impl_.header_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(RpcMessage), alignof(RpcMessage), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&RpcMessage::PlacementNew_, + sizeof(RpcMessage), + alignof(RpcMessage)); + } +} +constexpr auto RpcMessage::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RpcMessage_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RpcMessage::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RpcMessage::SharedDtor, + static_cast(&RpcMessage::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_._cached_size_), + false, + }, + &RpcMessage::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_ = + RpcMessage::InternalGenerateClassData_(); -::_pbi::CachedSize* RpcMessage::AccessCachedSize() const { - return &_impl_._cached_size_; +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RpcMessage::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RpcMessage_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RpcMessage_class_data_.tc_table); + return RpcMessage_class_data_.base(); } -void RpcMessage::InternalSwap(RpcMessage* PROTOBUF_RESTRICT other) { - using std::swap; +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 2, 78, 2> +RpcMessage::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RpcMessage, _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 + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RpcMessage_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::RpcMessage>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + // .google.protobuf.Any body = 2; + {::_pbi::TcParser::FastMtS1, + {18, 4, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.body_)}}, + // string requestId = 3; + {::_pbi::TcParser::FastUS1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.requestid_)}}, + // optional .protorpc.RpcErrorType errorType = 4; + {::_pbi::TcParser::FastV32S1, + {32, 5, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errortype_)}}, + // optional string errorClassName = 5; + {::_pbi::TcParser::FastUS1, + {42, 1, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorclassname_)}}, + // optional string errorCode = 6; + {::_pbi::TcParser::FastUS1, + {50, 2, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorcode_)}}, + // optional string errorMessage = 7; + {::_pbi::TcParser::FastUS1, + {58, 3, 0, + PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errormessage_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // map header = 1; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.header_), _Internal::kHasBitsOffset + 6, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMap)}, + // .google.protobuf.Any body = 2; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.body_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string requestId = 3; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.requestid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .protorpc.RpcErrorType errorType = 4; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errortype_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // optional string errorClassName = 5; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorclassname_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string errorCode = 6; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errorcode_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string errorMessage = 7; + {PROTOBUF_FIELD_OFFSET(RpcMessage, _impl_.errormessage_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Any>()}, + {::_pbi::TcParser::GetMapAuxInfo( + 1, 0, 9, 9, 0)}, + }}, + {{ + "\23\6\0\11\0\16\11\14" + "protorpc.RpcMessage" + "header" + "requestId" + "errorClassName" + "errorCode" + "errorMessage" + }}, +}; +void RpcMessage::InternalSwap(RpcMessage* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata RpcMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[1]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Mnfo2uhnf92hvqi2nviouq2hv9puhq::_Internal { public: - using HasBits = decltype(std::declval()._impl_._has_bits_); + using HasBits = + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_); - static const ::google::protobuf::Empty& empty(const Mnfo2uhnf92hvqi2nviouq2hv9puhq* msg); - static void set_has_empty(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } + 8 * PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._has_bits_); }; -const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::_Internal::empty(const Mnfo2uhnf92hvqi2nviouq2hv9puhq* msg) { - return *msg->_impl_.empty_; -} void Mnfo2uhnf92hvqi2nviouq2hv9puhq::clear_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.empty_ != nullptr) _impl_.empty_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena) +Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) } -inline PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from) +PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} Mnfo2uhnf92hvqi2nviouq2hv9puhq::Mnfo2uhnf92hvqi2nviouq2hv9puhq( - ::google::protobuf::Arena* arena, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.empty_ = (cached_has_bits & 0x00000001u) - ? CreateMaybeMessage<::google::protobuf::Empty>(arena, *from._impl_.empty_) + _impl_.empty_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.empty_) : nullptr; // @@protoc_insertion_point(copy_constructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) } -inline PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) +PROTOBUF_NDEBUG_INLINE Mnfo2uhnf92hvqi2nviouq2hv9puhq::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0} {} -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedCtor(::_pb::Arena* arena) { +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.empty_ = {}; } Mnfo2uhnf92hvqi2nviouq2hv9puhq::~Mnfo2uhnf92hvqi2nviouq2hv9puhq() { // @@protoc_insertion_point(destructor:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) - _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - SharedDtor(); + SharedDtor(*this); } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor() { - ABSL_DCHECK(GetArena() == nullptr); - delete _impl_.empty_; - _impl_.~Impl_(); +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor(MessageLite& self) { + Mnfo2uhnf92hvqi2nviouq2hv9puhq& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.empty_; + this_._impl_.~Impl_(); } -::_pbi::CachedSize* Mnfo2uhnf92hvqi2nviouq2hv9puhq::AccessCachedSize() const { - return &_impl_._cached_size_; +inline void* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) Mnfo2uhnf92hvqi2nviouq2hv9puhq(arena); +} +constexpr auto Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Mnfo2uhnf92hvqi2nviouq2hv9puhq), + alignof(Mnfo2uhnf92hvqi2nviouq2hv9puhq)); } -void Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_RESTRICT other) { - using std::swap; +constexpr auto Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::SharedDtor, + static_cast(&Mnfo2uhnf92hvqi2nviouq2hv9puhq::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_._cached_size_), + false, + }, + &Mnfo2uhnf92hvqi2nviouq2hv9puhq::kDescriptorMethods, + &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_ = + Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +Mnfo2uhnf92hvqi2nviouq2hv9puhq::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.tc_table); + return Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +Mnfo2uhnf92hvqi2nviouq2hv9puhq::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _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), + Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::protorpc::Mnfo2uhnf92hvqi2nviouq2hv9puhq>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .google.protobuf.Empty empty = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .google.protobuf.Empty empty = 1; + {PROTOBUF_FIELD_OFFSET(Mnfo2uhnf92hvqi2nviouq2hv9puhq, _impl_.empty_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::google::protobuf::Empty>()}, + }}, + {{ + }}, +}; +void Mnfo2uhnf92hvqi2nviouq2hv9puhq::InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; GetReflection()->Swap(this, other);} ::google::protobuf::Metadata Mnfo2uhnf92hvqi2nviouq2hv9puhq::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_getter, &descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_once, - file_level_metadata_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto[2]); + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace protorpc @@ -427,4 +710,8 @@ namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ [[maybe_unused]] = + (::_pbi::AddDescriptors(&descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto), + ::std::false_type{}); #include "google/protobuf/port_undef.inc" diff --git a/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h b/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h index 97869d4b..a3861406 100644 --- a/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h +++ b/packages/streamr-trackerless-network/src/proto/packages/proto-rpc/protos/ProtoRpc.pb.h @@ -1,28 +1,22 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE // source: packages/proto-rpc/protos/ProtoRpc.proto -// Protobuf C++ Version: 4.25.1 +// Protobuf C++ Version: 6.33.4 -#ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh -#define GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#ifndef packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#define packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh #include #include #include #include -#include "google/protobuf/port_def.inc" -#if PROTOBUF_VERSION < 4025000 -#error "This file was generated by a newer version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please update" -#error "your headers." -#endif // PROTOBUF_VERSION - -#if 4025001 < PROTOBUF_MIN_PROTOC_VERSION -#error "This file was generated by an older version of protoc which is" -#error "incompatible with your Protocol Buffer headers. Please" -#error "regenerate this file with a newer version of protoc." -#endif // PROTOBUF_MIN_PROTOC_VERSION -#include "google/protobuf/port_undef.inc" +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 6033004 +#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" @@ -30,11 +24,13 @@ #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/map.h" // IWYU pragma: export +#include "google/protobuf/map_type_handler.h" // IWYU pragma: export #include "google/protobuf/map_entry.h" -#include "google/protobuf/map_field_inl.h" +#include "google/protobuf/map_field.h" #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" @@ -49,7 +45,8 @@ namespace google { namespace protobuf { namespace internal { -class AnyMetadata; +template +::absl::string_view GetAnyMessageName(); } // namespace internal } // namespace protobuf } // namespace google @@ -58,21 +55,30 @@ class AnyMetadata; struct TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto { static const ::uint32_t offsets[]; }; -extern const ::google::protobuf::internal::DescriptorTable - descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; +extern "C" { +extern const ::google::protobuf::internal::DescriptorTable descriptor_table_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; +} // extern "C" namespace protorpc { +enum RpcErrorType : int; +extern const uint32_t RpcErrorType_internal_data_[]; class Mnfo2uhnf92hvqi2nviouq2hv9puhq; struct Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal; extern Mnfo2uhnf92hvqi2nviouq2hv9puhqDefaultTypeInternal _Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_; class RpcMessage; struct RpcMessageDefaultTypeInternal; extern RpcMessageDefaultTypeInternal _RpcMessage_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_; class RpcMessage_HeaderEntry_DoNotUse; struct RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal; extern RpcMessage_HeaderEntry_DoNotUseDefaultTypeInternal _RpcMessage_HeaderEntry_DoNotUse_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_; } // namespace protorpc namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::protorpc::RpcErrorType_internal_data_> + internal::EnumTraitsImpl::value<::protorpc::RpcErrorType>; } // namespace protobuf } // namespace google @@ -84,34 +90,37 @@ enum RpcErrorType : int { CLIENT_ERROR = 3, SERVER_ERROR = 4, RpcErrorType_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::min(), + ::std::numeric_limits<::int32_t>::min(), RpcErrorType_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits<::int32_t>::max(), + ::std::numeric_limits<::int32_t>::max(), }; -bool RpcErrorType_IsValid(int value); extern const uint32_t RpcErrorType_internal_data_[]; -constexpr RpcErrorType RpcErrorType_MIN = static_cast(0); -constexpr RpcErrorType RpcErrorType_MAX = static_cast(4); -constexpr int RpcErrorType_ARRAYSIZE = 4 + 1; -const ::google::protobuf::EnumDescriptor* -RpcErrorType_descriptor(); +inline constexpr RpcErrorType RpcErrorType_MIN = + static_cast(0); +inline constexpr RpcErrorType RpcErrorType_MAX = + static_cast(4); +inline bool RpcErrorType_IsValid(int value) { + return 0 <= value && value <= 4; +} +inline constexpr int RpcErrorType_ARRAYSIZE = 4 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RpcErrorType_descriptor(); template -const std::string& RpcErrorType_Name(T value) { - static_assert(std::is_same::value || - std::is_integral::value, +const ::std::string& RpcErrorType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, "Incorrect type passed to RpcErrorType_Name()."); return RpcErrorType_Name(static_cast(value)); } template <> -inline const std::string& RpcErrorType_Name(RpcErrorType value) { - return ::google::protobuf::internal::NameOfDenseEnum( +inline const ::std::string& RpcErrorType_Name(RpcErrorType value) { + return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } -inline bool RpcErrorType_Parse(absl::string_view name, RpcErrorType* value) { - return ::google::protobuf::internal::ParseNamedEnum( - RpcErrorType_descriptor(), name, value); +inline bool RpcErrorType_Parse( + ::absl::string_view name, RpcErrorType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(RpcErrorType_descriptor(), name, + value); } // =================================================================== @@ -120,61 +129,70 @@ inline bool RpcErrorType_Parse(absl::string_view name, RpcErrorType* value) { // ------------------------------------------------------------------- class RpcMessage_HeaderEntry_DoNotUse final - : public ::google::protobuf::internal::MapEntry< - RpcMessage_HeaderEntry_DoNotUse, std::string, std::string, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING> { + : public ::google::protobuf::internal::MapEntry<::std::string, ::std::string, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING> { public: - using SuperType = ::google::protobuf::internal::MapEntry< - RpcMessage_HeaderEntry_DoNotUse, std::string, std::string, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING, - ::google::protobuf::internal::WireFormatLite::TYPE_STRING>; + using SuperType = + ::google::protobuf::internal::MapEntry<::std::string, ::std::string, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING, + ::google::protobuf::internal::WireFormatLite::TYPE_STRING>; RpcMessage_HeaderEntry_DoNotUse(); template - explicit PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse( - ::google::protobuf::internal::ConstantInitialized); - explicit RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* arena); - static const RpcMessage_HeaderEntry_DoNotUse* internal_default_instance() { - return reinterpret_cast( - &_RpcMessage_HeaderEntry_DoNotUse_default_instance_); + explicit PROTOBUF_CONSTEXPR RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::internal::ConstantInitialized); + explicit RpcMessage_HeaderEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr const void* PROTOBUF_NONNULL internal_default_instance() { + return &_RpcMessage_HeaderEntry_DoNotUse_default_instance_; } - static bool ValidateKey(std::string* s) { - return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "protorpc.RpcMessage.HeaderEntry.key"); - } - static bool ValidateValue(std::string* s) { - return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "protorpc.RpcMessage.HeaderEntry.value"); - } - ::google::protobuf::Metadata GetMetadata() const final; + + + static constexpr auto InternalGenerateClassData_(); + + private: + friend class ::google::protobuf::MessageLite; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 48, + 2> + _table_; + + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); }; +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_HeaderEntry_DoNotUse_class_data_; // ------------------------------------------------------------------- -class RpcMessage final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protorpc.RpcMessage) */ { +class RpcMessage final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:protorpc.RpcMessage) */ { public: inline RpcMessage() : RpcMessage(nullptr) {} - ~RpcMessage() override; - template - explicit PROTOBUF_CONSTEXPR RpcMessage(::google::protobuf::internal::ConstantInitialized); + ~RpcMessage() PROTOBUF_FINAL; - inline RpcMessage(const RpcMessage& from) - : RpcMessage(nullptr, from) {} - RpcMessage(RpcMessage&& from) noexcept - : RpcMessage() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RpcMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RpcMessage)); } +#endif + template + explicit PROTOBUF_CONSTEXPR RpcMessage(::google::protobuf::internal::ConstantInitialized); + + inline RpcMessage(const RpcMessage& from) : RpcMessage(nullptr, from) {} + inline RpcMessage(RpcMessage&& from) noexcept + : RpcMessage(nullptr, ::std::move(from)) {} inline RpcMessage& operator=(const RpcMessage& from) { CopyFrom(from); return *this; } inline RpcMessage& operator=(RpcMessage&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -186,47 +204,35 @@ class RpcMessage final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const RpcMessage& default_instance() { - return *internal_default_instance(); - } - static inline const RpcMessage* internal_default_instance() { - return reinterpret_cast( - &_RpcMessage_default_instance_); + return *reinterpret_cast( + &_RpcMessage_default_instance_); } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(RpcMessage& a, RpcMessage& b) { - a.Swap(&b); - } - inline void Swap(RpcMessage* other) { + static constexpr int kIndexInFileMessages = 1; + friend void swap(RpcMessage& a, RpcMessage& b) { a.Swap(&b); } + inline void Swap(RpcMessage* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RpcMessage* other) { + void UnsafeArenaSwap(RpcMessage* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -234,138 +240,125 @@ class RpcMessage final : // implements Message ---------------------------------------------- - RpcMessage* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + RpcMessage* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(RpcMessage* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "protorpc.RpcMessage"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RpcMessage* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "protorpc.RpcMessage"; } + + explicit RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RpcMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RpcMessage& from); + RpcMessage( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RpcMessage&& from) noexcept + : RpcMessage(arena) { + *this = ::std::move(from); } - protected: - explicit RpcMessage(::google::protobuf::Arena* arena); - RpcMessage(::google::protobuf::Arena* arena, const RpcMessage& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- - // accessors ------------------------------------------------------- - enum : int { - kHeaderFieldNumber = 1, kRequestIdFieldNumber = 3, kErrorClassNameFieldNumber = 5, kErrorCodeFieldNumber = 6, kErrorMessageFieldNumber = 7, kBodyFieldNumber = 2, kErrorTypeFieldNumber = 4, + kHeaderFieldNumber = 1, }; - // map header = 1; - int header_size() const; - private: - int _internal_header_size() const; - - public: - void clear_header() ; - const ::google::protobuf::Map& header() const; - ::google::protobuf::Map* mutable_header(); - - private: - const ::google::protobuf::Map& _internal_header() const; - ::google::protobuf::Map* _internal_mutable_header(); - - public: // string requestId = 3; void clear_requestid() ; - const std::string& requestid() const; - template + const ::std::string& requestid() const; + template void set_requestid(Arg_&& arg, Args_... args); - std::string* mutable_requestid(); - PROTOBUF_NODISCARD std::string* release_requestid(); - void set_allocated_requestid(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_requestid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_requestid(); + void set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_requestid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid( - const std::string& value); - std::string* _internal_mutable_requestid(); + const ::std::string& _internal_requestid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_requestid(); public: // optional string errorClassName = 5; bool has_errorclassname() const; void clear_errorclassname() ; - const std::string& errorclassname() const; - template + const ::std::string& errorclassname() const; + template void set_errorclassname(Arg_&& arg, Args_... args); - std::string* mutable_errorclassname(); - PROTOBUF_NODISCARD std::string* release_errorclassname(); - void set_allocated_errorclassname(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errorclassname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errorclassname(); + void set_allocated_errorclassname(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errorclassname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errorclassname( - const std::string& value); - std::string* _internal_mutable_errorclassname(); + const ::std::string& _internal_errorclassname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errorclassname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errorclassname(); public: // optional string errorCode = 6; bool has_errorcode() const; void clear_errorcode() ; - const std::string& errorcode() const; - template + const ::std::string& errorcode() const; + template void set_errorcode(Arg_&& arg, Args_... args); - std::string* mutable_errorcode(); - PROTOBUF_NODISCARD std::string* release_errorcode(); - void set_allocated_errorcode(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errorcode(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errorcode(); + void set_allocated_errorcode(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errorcode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errorcode( - const std::string& value); - std::string* _internal_mutable_errorcode(); + const ::std::string& _internal_errorcode() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errorcode(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errorcode(); public: // optional string errorMessage = 7; bool has_errormessage() const; void clear_errormessage() ; - const std::string& errormessage() const; - template + const ::std::string& errormessage() const; + template void set_errormessage(Arg_&& arg, Args_... args); - std::string* mutable_errormessage(); - PROTOBUF_NODISCARD std::string* release_errormessage(); - void set_allocated_errormessage(std::string* value); + ::std::string* PROTOBUF_NONNULL mutable_errormessage(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_errormessage(); + void set_allocated_errormessage(::std::string* PROTOBUF_NULLABLE value); private: - const std::string& _internal_errormessage() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_errormessage( - const std::string& value); - std::string* _internal_mutable_errormessage(); + const ::std::string& _internal_errormessage() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_errormessage(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_errormessage(); public: // .google.protobuf.Any body = 2; bool has_body() const; void clear_body() ; const ::google::protobuf::Any& body() const; - PROTOBUF_NODISCARD ::google::protobuf::Any* release_body(); - ::google::protobuf::Any* mutable_body(); - void set_allocated_body(::google::protobuf::Any* value); - void unsafe_arena_set_allocated_body(::google::protobuf::Any* value); - ::google::protobuf::Any* unsafe_arena_release_body(); + [[nodiscard]] ::google::protobuf::Any* PROTOBUF_NULLABLE release_body(); + ::google::protobuf::Any* PROTOBUF_NONNULL mutable_body(); + void set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value); + ::google::protobuf::Any* PROTOBUF_NULLABLE unsafe_arena_release_body(); private: const ::google::protobuf::Any& _internal_body() const; - ::google::protobuf::Any* _internal_mutable_body(); + ::google::protobuf::Any* PROTOBUF_NONNULL _internal_mutable_body(); public: // optional .protorpc.RpcErrorType errorType = 4; @@ -378,10 +371,30 @@ class RpcMessage final : ::protorpc::RpcErrorType _internal_errortype() const; void _internal_set_errortype(::protorpc::RpcErrorType value); + public: + // map header = 1; + int header_size() const; + private: + int _internal_header_size() const; + + public: + void clear_header() ; + const ::google::protobuf::Map<::std::string, ::std::string>& header() const; + ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL mutable_header(); + + private: + const ::google::protobuf::Map<::std::string, ::std::string>& _internal_header() const; + ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL _internal_mutable_header(); + public: // @@protoc_insertion_point(class_scope:protorpc.RpcMessage) private: class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 7, + 2, 78, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -390,57 +403,61 @@ class RpcMessage final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RpcMessage& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::MapField - header_; + ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr requestid_; ::google::protobuf::internal::ArenaStringPtr errorclassname_; ::google::protobuf::internal::ArenaStringPtr errorcode_; ::google::protobuf::internal::ArenaStringPtr errormessage_; - ::google::protobuf::Any* body_; + ::google::protobuf::Any* PROTOBUF_NULLABLE body_; int errortype_; + ::google::protobuf::internal::MapField + header_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; -};// ------------------------------------------------------------------- +}; + +extern const ::google::protobuf::internal::ClassDataFull RpcMessage_class_data_; +// ------------------------------------------------------------------- -class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : - public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) */ { +class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) */ { public: inline Mnfo2uhnf92hvqi2nviouq2hv9puhq() : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr) {} - ~Mnfo2uhnf92hvqi2nviouq2hv9puhq() override; - template - explicit PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::internal::ConstantInitialized); + ~Mnfo2uhnf92hvqi2nviouq2hv9puhq() PROTOBUF_FINAL; - inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) - : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, from) {} - Mnfo2uhnf92hvqi2nviouq2hv9puhq(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept - : Mnfo2uhnf92hvqi2nviouq2hv9puhq() { - *this = ::std::move(from); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Mnfo2uhnf92hvqi2nviouq2hv9puhq)); } +#endif + template + explicit PROTOBUF_CONSTEXPR Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::internal::ConstantInitialized); + + inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, from) {} + inline Mnfo2uhnf92hvqi2nviouq2hv9puhq(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept + : Mnfo2uhnf92hvqi2nviouq2hv9puhq(nullptr, ::std::move(from)) {} inline Mnfo2uhnf92hvqi2nviouq2hv9puhq& operator=(const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from) { CopyFrom(from); return *this; } inline Mnfo2uhnf92hvqi2nviouq2hv9puhq& operator=(Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept { if (this == &from) return *this; - if (GetArena() == from.GetArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); } else { CopyFrom(from); @@ -452,47 +469,35 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - static const ::google::protobuf::Descriptor* descriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { return GetDescriptor(); } - static const ::google::protobuf::Descriptor* GetDescriptor() { + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { return default_instance().GetMetadata().descriptor; } - static const ::google::protobuf::Reflection* GetReflection() { + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } static const Mnfo2uhnf92hvqi2nviouq2hv9puhq& default_instance() { - return *internal_default_instance(); - } - static inline const Mnfo2uhnf92hvqi2nviouq2hv9puhq* internal_default_instance() { - return reinterpret_cast( - &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq& a, Mnfo2uhnf92hvqi2nviouq2hv9puhq& b) { - a.Swap(&b); + return *reinterpret_cast( + &_Mnfo2uhnf92hvqi2nviouq2hv9puhq_default_instance_); } - inline void Swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other) { + static constexpr int kIndexInFileMessages = 2; + friend void swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq& a, Mnfo2uhnf92hvqi2nviouq2hv9puhq& b) { a.Swap(&b); } + inline void Swap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other) { if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() != nullptr && - GetArena() == other->GetArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetArena() == other->GetArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other) { + void UnsafeArenaSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -500,33 +505,40 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : // implements Message ---------------------------------------------- - Mnfo2uhnf92hvqi2nviouq2hv9puhq* New(::google::protobuf::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: - ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; - void SharedCtor(::google::protobuf::Arena* arena); - void SharedDtor(); - void InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* other); - - private: - friend class ::google::protobuf::internal::AnyMetadata; - static ::absl::string_view FullMessageName() { - return "protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq"; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Mnfo2uhnf92hvqi2nviouq2hv9puhq* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq"; } + + explicit Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from); + Mnfo2uhnf92hvqi2nviouq2hv9puhq( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Mnfo2uhnf92hvqi2nviouq2hv9puhq&& from) noexcept + : Mnfo2uhnf92hvqi2nviouq2hv9puhq(arena) { + *this = ::std::move(from); } - protected: - explicit Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena); - Mnfo2uhnf92hvqi2nviouq2hv9puhq(::google::protobuf::Arena* arena, const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from); - public: + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - ::google::protobuf::Metadata GetMetadata() const final; + public: + static constexpr auto InternalGenerateClassData_(); + ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- - enum : int { kEmptyFieldNumber = 1, }; @@ -534,20 +546,25 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : bool has_empty() const; void clear_empty() ; const ::google::protobuf::Empty& empty() const; - PROTOBUF_NODISCARD ::google::protobuf::Empty* release_empty(); - ::google::protobuf::Empty* mutable_empty(); - void set_allocated_empty(::google::protobuf::Empty* value); - void unsafe_arena_set_allocated_empty(::google::protobuf::Empty* value); - ::google::protobuf::Empty* unsafe_arena_release_empty(); + [[nodiscard]] ::google::protobuf::Empty* PROTOBUF_NULLABLE release_empty(); + ::google::protobuf::Empty* PROTOBUF_NONNULL mutable_empty(); + void set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value); + ::google::protobuf::Empty* PROTOBUF_NULLABLE unsafe_arena_release_empty(); private: const ::google::protobuf::Empty& _internal_empty() const; - ::google::protobuf::Empty* _internal_mutable_empty(); + ::google::protobuf::Empty* PROTOBUF_NONNULL _internal_mutable_empty(); public: // @@protoc_insertion_point(class_scope:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq) 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; @@ -556,22 +573,25 @@ class Mnfo2uhnf92hvqi2nviouq2hv9puhq final : 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); + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const Mnfo2uhnf92hvqi2nviouq2hv9puhq& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; - mutable ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::Empty* empty_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::Empty* PROTOBUF_NULLABLE empty_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto; }; +extern const ::google::protobuf::internal::ClassDataFull Mnfo2uhnf92hvqi2nviouq2hv9puhq_class_data_; + // =================================================================== @@ -598,34 +618,38 @@ inline int RpcMessage::header_size() const { return _internal_header_size(); } inline void RpcMessage::clear_header() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000040U); } -inline const ::google::protobuf::Map& RpcMessage::_internal_header() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::google::protobuf::Map<::std::string, ::std::string>& RpcMessage::_internal_header() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.header_.GetMap(); } -inline const ::google::protobuf::Map& RpcMessage::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline const ::google::protobuf::Map<::std::string, ::std::string>& RpcMessage::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_map:protorpc.RpcMessage.header) return _internal_header(); } -inline ::google::protobuf::Map* RpcMessage::_internal_mutable_header() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL RpcMessage::_internal_mutable_header() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.header_.MutableMap(); } -inline ::google::protobuf::Map* RpcMessage::mutable_header() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL RpcMessage::mutable_header() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000040U); // @@protoc_insertion_point(field_mutable_map:protorpc.RpcMessage.header) return _internal_mutable_header(); } // .google.protobuf.Any body = 2; inline bool RpcMessage::has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); return value; } inline const ::google::protobuf::Any& RpcMessage::_internal_body() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Any* p = _impl_.body_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Any_default_instance_); } @@ -633,76 +657,78 @@ inline const ::google::protobuf::Any& RpcMessage::body() const ABSL_ATTRIBUTE_LI // @@protoc_insertion_point(field_get:protorpc.RpcMessage.body) return _internal_body(); } -inline void RpcMessage::unsafe_arena_set_allocated_body(::google::protobuf::Any* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::unsafe_arena_set_allocated_body( + ::google::protobuf::Any* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protorpc.RpcMessage.body) } -inline ::google::protobuf::Any* RpcMessage::release_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE RpcMessage::release_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* released = _impl_.body_; _impl_.body_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Any* RpcMessage::unsafe_arena_release_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Any* PROTOBUF_NULLABLE RpcMessage::unsafe_arena_release_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.body) - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* temp = _impl_.body_; _impl_.body_ = nullptr; return temp; } -inline ::google::protobuf::Any* RpcMessage::_internal_mutable_body() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000008u; +inline ::google::protobuf::Any* PROTOBUF_NONNULL RpcMessage::_internal_mutable_body() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Any>(GetArena()); _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(p); } return _impl_.body_; } -inline ::google::protobuf::Any* RpcMessage::mutable_body() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Any* PROTOBUF_NONNULL RpcMessage::mutable_body() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); ::google::protobuf::Any* _msg = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.body) return _msg; } -inline void RpcMessage::set_allocated_body(::google::protobuf::Any* value) { +inline void RpcMessage::set_allocated_body(::google::protobuf::Any* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000008u; + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - _impl_._has_bits_[0] &= ~0x00000008u; + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } _impl_.body_ = reinterpret_cast<::google::protobuf::Any*>(value); @@ -711,66 +737,79 @@ inline void RpcMessage::set_allocated_body(::google::protobuf::Any* value) { // string requestId = 3; inline void RpcMessage::clear_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline const std::string& RpcMessage::requestid() const +inline const ::std::string& RpcMessage::requestid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.requestId) return _internal_requestid(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_requestid(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_requestid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.requestid_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.requestId) } -inline std::string* RpcMessage::mutable_requestid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_requestid(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_requestid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_requestid(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.requestId) return _s; } -inline const std::string& RpcMessage::_internal_requestid() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_requestid() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requestid_.Get(); } -inline void RpcMessage::_internal_set_requestid(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline void RpcMessage::_internal_set_requestid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requestid_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - ; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.requestid_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_requestid() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_requestid() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.requestId) - return _impl_.requestid_.Release(); + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.requestid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.requestid_.Set("", GetArena()); + } + return released; } -inline void RpcMessage::set_allocated_requestid(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_requestid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } _impl_.requestid_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestid_.IsDefault()) { - _impl_.requestid_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.requestid_.IsDefault()) { + _impl_.requestid_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.requestId) } // optional .protorpc.RpcErrorType errorType = 4; inline bool RpcMessage::has_errortype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); return value; } inline void RpcMessage::clear_errortype() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errortype_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } inline ::protorpc::RpcErrorType RpcMessage::errortype() const { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorType) @@ -778,228 +817,222 @@ inline ::protorpc::RpcErrorType RpcMessage::errortype() const { } inline void RpcMessage::set_errortype(::protorpc::RpcErrorType value) { _internal_set_errortype(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorType) } inline ::protorpc::RpcErrorType RpcMessage::_internal_errortype() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::protorpc::RpcErrorType>(_impl_.errortype_); } inline void RpcMessage::_internal_set_errortype(::protorpc::RpcErrorType value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000010u; + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errortype_ = value; } // optional string errorClassName = 5; inline bool RpcMessage::has_errorclassname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); return value; } inline void RpcMessage::clear_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorclassname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const std::string& RpcMessage::errorclassname() const +inline const ::std::string& RpcMessage::errorclassname() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorClassName) return _internal_errorclassname(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorclassname(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorclassname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); _impl_.errorclassname_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorClassName) } -inline std::string* RpcMessage::mutable_errorclassname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errorclassname(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errorclassname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_errorclassname(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorClassName) return _s; } -inline const std::string& RpcMessage::_internal_errorclassname() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errorclassname() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errorclassname_.Get(); } -inline void RpcMessage::_internal_set_errorclassname(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline void RpcMessage::_internal_set_errorclassname(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorclassname_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errorclassname() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errorclassname_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errorclassname() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errorclassname() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorClassName) - if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); auto* released = _impl_.errorclassname_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errorclassname_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errorclassname_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errorclassname(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errorclassname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } _impl_.errorclassname_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errorclassname_.IsDefault()) { - _impl_.errorclassname_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errorclassname_.IsDefault()) { + _impl_.errorclassname_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorClassName) } // optional string errorCode = 6; inline bool RpcMessage::has_errorcode() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); return value; } inline void RpcMessage::clear_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorcode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline const std::string& RpcMessage::errorcode() const +inline const ::std::string& RpcMessage::errorcode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorCode) return _internal_errorcode(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorcode(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errorcode(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); _impl_.errorcode_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorCode) } -inline std::string* RpcMessage::mutable_errorcode() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errorcode(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errorcode() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_errorcode(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorCode) return _s; } -inline const std::string& RpcMessage::_internal_errorcode() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errorcode() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errorcode_.Get(); } -inline void RpcMessage::_internal_set_errorcode(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline void RpcMessage::_internal_set_errorcode(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errorcode_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000002u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errorcode() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errorcode_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errorcode() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errorcode() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorCode) - if ((_impl_._has_bits_[0] & 0x00000002u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); auto* released = _impl_.errorcode_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errorcode_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errorcode_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errorcode(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errorcode(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - _impl_._has_bits_[0] &= ~0x00000002u; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.errorcode_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errorcode_.IsDefault()) { - _impl_.errorcode_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errorcode_.IsDefault()) { + _impl_.errorcode_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorCode) } // optional string errorMessage = 7; inline bool RpcMessage::has_errormessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); return value; } inline void RpcMessage::clear_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errormessage_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const std::string& RpcMessage::errormessage() const +inline const ::std::string& RpcMessage::errormessage() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:protorpc.RpcMessage.errorMessage) return _internal_errormessage(); } template -inline PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errormessage(Arg_&& arg, - Args_... args) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +PROTOBUF_ALWAYS_INLINE void RpcMessage::set_errormessage(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); _impl_.errormessage_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:protorpc.RpcMessage.errorMessage) } -inline std::string* RpcMessage::mutable_errormessage() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_errormessage(); +inline ::std::string* PROTOBUF_NONNULL RpcMessage::mutable_errormessage() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_errormessage(); // @@protoc_insertion_point(field_mutable:protorpc.RpcMessage.errorMessage) return _s; } -inline const std::string& RpcMessage::_internal_errormessage() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); +inline const ::std::string& RpcMessage::_internal_errormessage() const { + ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errormessage_.Get(); } -inline void RpcMessage::_internal_set_errormessage(const std::string& value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline void RpcMessage::_internal_set_errormessage(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errormessage_.Set(value, GetArena()); } -inline std::string* RpcMessage::_internal_mutable_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000004u; +inline ::std::string* PROTOBUF_NONNULL RpcMessage::_internal_mutable_errormessage() { + ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.errormessage_.Mutable( GetArena()); } -inline std::string* RpcMessage::release_errormessage() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::std::string* PROTOBUF_NULLABLE RpcMessage::release_errormessage() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.RpcMessage.errorMessage) - if ((_impl_._has_bits_[0] & 0x00000004u) == 0) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { return nullptr; } - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); auto* released = _impl_.errormessage_.Release(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.errormessage_.Set("", GetArena()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.errormessage_.Set("", GetArena()); + } return released; } -inline void RpcMessage::set_allocated_errormessage(std::string* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void RpcMessage::set_allocated_errormessage(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - _impl_._has_bits_[0] &= ~0x00000004u; + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } _impl_.errormessage_.SetAllocated(value, GetArena()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.errormessage_.IsDefault()) { - _impl_.errormessage_.Set("", GetArena()); - } - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.errormessage_.IsDefault()) { + _impl_.errormessage_.Set("", GetArena()); + } // @@protoc_insertion_point(field_set_allocated:protorpc.RpcMessage.errorMessage) } @@ -1009,12 +1042,12 @@ inline void RpcMessage::set_allocated_errormessage(std::string* value) { // .google.protobuf.Empty empty = 1; inline bool Mnfo2uhnf92hvqi2nviouq2hv9puhq::has_empty() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); PROTOBUF_ASSUME(!value || _impl_.empty_ != nullptr); return value; } inline const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_empty() const { - PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanRead(&_impl_); const ::google::protobuf::Empty* p = _impl_.empty_; return p != nullptr ? *p : reinterpret_cast(::google::protobuf::_Empty_default_instance_); } @@ -1022,76 +1055,78 @@ inline const ::google::protobuf::Empty& Mnfo2uhnf92hvqi2nviouq2hv9puhq::empty() // @@protoc_insertion_point(field_get:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) return _internal_empty(); } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_set_allocated_empty(::google::protobuf::Empty* value) { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_set_allocated_empty( + ::google::protobuf::Empty* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.empty_); } _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(value); if (value != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::release_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Empty* PROTOBUF_NULLABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq::release_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* released = _impl_.empty_; _impl_.empty_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArena() != 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); + } } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_release_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); +inline ::google::protobuf::Empty* PROTOBUF_NULLABLE Mnfo2uhnf92hvqi2nviouq2hv9puhq::unsafe_arena_release_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* temp = _impl_.empty_; _impl_.empty_ = nullptr; return temp; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_mutable_empty() { - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); - _impl_._has_bits_[0] |= 0x00000001u; +inline ::google::protobuf::Empty* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::_internal_mutable_empty() { + ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.empty_ == nullptr) { - auto* p = CreateMaybeMessage<::google::protobuf::Empty>(GetArena()); + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Empty>(GetArena()); _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(p); } return _impl_.empty_; } -inline ::google::protobuf::Empty* Mnfo2uhnf92hvqi2nviouq2hv9puhq::mutable_empty() ABSL_ATTRIBUTE_LIFETIME_BOUND { +inline ::google::protobuf::Empty* PROTOBUF_NONNULL Mnfo2uhnf92hvqi2nviouq2hv9puhq::mutable_empty() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::google::protobuf::Empty* _msg = _internal_mutable_empty(); // @@protoc_insertion_point(field_mutable:protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq.empty) return _msg; } -inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::set_allocated_empty(::google::protobuf::Empty* value) { +inline void Mnfo2uhnf92hvqi2nviouq2hv9puhq::set_allocated_empty(::google::protobuf::Empty* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); - PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.empty_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_._has_bits_[0] |= 0x00000001u; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - _impl_._has_bits_[0] &= ~0x00000001u; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } _impl_.empty_ = reinterpret_cast<::google::protobuf::Empty*>(value); @@ -1112,7 +1147,7 @@ namespace protobuf { template <> struct is_proto_enum<::protorpc::RpcErrorType> : std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor<::protorpc::RpcErrorType>() { +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::protorpc::RpcErrorType>() { return ::protorpc::RpcErrorType_descriptor(); } @@ -1123,4 +1158,4 @@ inline const EnumDescriptor* GetEnumDescriptor<::protorpc::RpcErrorType>() { #include "google/protobuf/port_undef.inc" -#endif // GOOGLE_PROTOBUF_INCLUDED_packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh +#endif // packages_2fproto_2drpc_2fprotos_2fProtoRpc_2eproto_2epb_2eh diff --git a/packages/streamr-utils/CMakeLists.txt b/packages/streamr-utils/CMakeLists.txt index 85c3ea32..2e628cc5 100644 --- a/packages/streamr-utils/CMakeLists.txt +++ b/packages/streamr-utils/CMakeLists.txt @@ -46,7 +46,12 @@ target_include_directories( $) find_library(SECP256K1_LIBRARY secp256k1) +# secp256k1 >= 0.7 links the precomputed tables into the main library; the +# separate secp256k1_precomputed archive no longer exists. find_library(SECP256K1_LIBRARY_PRECOMPUTED secp256k1_precomputed) +if(NOT SECP256K1_LIBRARY_PRECOMPUTED) + set(SECP256K1_LIBRARY_PRECOMPUTED "") +endif() message(STATUS "SECP256K1_LIBRARY_PRECOMPUTED: ${SECP256K1_LIBRARY_PRECOMPUTED}") target_link_libraries(streamr-utils @@ -72,6 +77,9 @@ file(WRITE "${CMAKE_BINARY_DIR}/streamr-utils-config.cmake" "find_package(cryptopp CONFIG REQUIRED)\n" "find_library(SECP256K1_LIBRARY secp256k1)\n" "find_library(SECP256K1_LIBRARY_PRECOMPUTED secp256k1_precomputed)\n" + "if(NOT SECP256K1_LIBRARY_PRECOMPUTED)\n" + " set(SECP256K1_LIBRARY_PRECOMPUTED \"\")\n" + "endif()\n" "if(NOT TARGET Boost::uuid)\n" " add_library(Boost::uuid INTERFACE IMPORTED)\n" " set_target_properties(Boost::uuid PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${Boost_INCLUDE_DIRS})\n" diff --git a/vcpkg b/vcpkg index f176b58f..cd61e1e2 160000 --- a/vcpkg +++ b/vcpkg @@ -1 +1 @@ -Subproject commit f176b58f35a75f9f8f54099cd9df97d2e2793a2e +Subproject commit cd61e1e26a038e82d6550a3ebbe0fbbfe7da78e3 diff --git a/vcpkg.json b/vcpkg.json index bbbe8b59..c0b62631 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -1,6 +1,7 @@ { "name": "streamr-native-sdk", "version": "1.0.0", + "builtin-baseline": "cd61e1e26a038e82d6550a3ebbe0fbbfe7da78e3", "dependencies": [ "ada-url", "boost-algorithm",