diff --git a/.ci/build-kit/docker/Dockerfile b/.ci/build-kit/docker/Dockerfile index e593b5cf9f..741de21344 100644 --- a/.ci/build-kit/docker/Dockerfile +++ b/.ci/build-kit/docker/Dockerfile @@ -13,3 +13,86 @@ FROM ghcr.io/everest/everest-ci/build-kit-base:${BASE_IMAGE_TAG} # FIXME(kai): Install libsystemd-dev as a dependency of sdbus-c++ RUN apt-get update && apt-get -y install libsystemd-dev +ADD "https://www.random.org/cgi-bin/randbyte?nbytes=10&format=h" skipcache +ENV EVEREST_CMAKE_PATH=/usr/lib/cmake/everest-cmake +ENV EVEREST_CMAKE_VERSION=tmp/eebus +RUN rm -rf ${EVEREST_CMAKE_PATH} \ + && git clone https://github.com/EVerest/everest-cmake.git ${EVEREST_CMAKE_PATH} \ + && cd ${EVEREST_CMAKE_PATH} \ + && git checkout ${EVEREST_CMAKE_VERSION} \ + && rm -r .git + +ARG GO_VERSION=1.24.2 +ADD https://go.dev/dl/go${GO_VERSION}.linux-amd64.tar.gz /tmp/go.tar.gz +RUN if [ -d /usr/local/go ]; then \ + echo "Go is already installed"; \ + else \ + tar -C /usr/local -xzf /tmp/go.tar.gz; \ + fi +ENV PATH="/usr/local/go/bin:${PATH}" +RUN go version + +ENV GRPC_VERSION=v1.71.0 +ENV GRPC_EXTENDED_CPP_PLUGIN_VERSION=main +RUN tmpdir=$(mktemp -d) \ + && cd $tmpdir \ + && git clone --depth 1 --recurse-submodules --shallow-submodules --branch ${GRPC_VERSION} https://github.com/grpc/grpc.git \ + && git clone --branch ${GRPC_EXTENDED_CPP_PLUGIN_VERSION} https://github.com/EVerest/grpc-extended-cpp-plugin.git \ + && cmake -B build -S grpc-extended-cpp-plugin -G Ninja -D gRPC_INSTALL=ON \ + && cmake --build build \ + && cmake --install build \ + && rm -rf $tmpdir + +RUN apt update \ + && apt install -y \ + build-essential \ + zlib1g-dev \ + libncurses5-dev \ + libgdbm-dev \ + libnss3-dev \ + libssl-dev \ + libreadline-dev \ + libffi-dev \ + libsqlite3-dev \ + wget +ENV PYTHON_VERSION=3.13.3 +ENV PYTHON_SOURCE_URL=https://www.python.org/ftp/python/${PYTHON_VERSION}/Python-${PYTHON_VERSION}.tgz +RUN tmpdir=$(mktemp -d) \ + && cd $tmpdir \ + && wget ${PYTHON_SOURCE_URL} \ + && tar -xzvf Python-${PYTHON_VERSION}.tgz \ + && cd Python-${PYTHON_VERSION} \ + && ./configure --enable-optimizations \ + && make -j $(nproc) \ + && make install \ + && short_version=$(echo ${PYTHON_VERSION} | cut -d. -f1-2) \ + && rm /usr/local/bin/python3 \ + && ln -s /usr/local/bin/python${short_version} /usr/local/bin/python3 + +RUN python3.13 -m pip install --break-system-packages \ + grpcio \ + grpcio-tools \ + pydantic \ + cryptography \ + netifaces \ + psutil \ + environs \ + py4j \ + aiofile \ + build \ + sphinx \ + gcovr \ + sphinxcontrib-contentui \ + sphinxcontrib-svg2pdfconverter \ + git+https://github.com/EVerest/everest-dev-environment@v0.7.1#subdirectory=dependency_manager + + +# Can be used to use an other version of everest-cmake +ADD "https://www.random.org/cgi-bin/randbyte?nbytes=10&format=h" skipcache +ENV EVEREST_CMAKE_PATH=/usr/lib/cmake/everest-cmake +ENV EVEREST_CMAKE_VERSION=tmp/eebus +RUN rm -rf ${EVEREST_CMAKE_PATH} \ + && git clone https://github.com/EVerest/everest-cmake.git ${EVEREST_CMAKE_PATH} \ + && cd ${EVEREST_CMAKE_PATH} \ + && git checkout ${EVEREST_CMAKE_VERSION} \ + && rm -r .git diff --git a/.ci/build-kit/scripts/compile.sh b/.ci/build-kit/scripts/compile.sh index bc50e26dfb..9728dd8c6b 100755 --- a/.ci/build-kit/scripts/compile.sh +++ b/.ci/build-kit/scripts/compile.sh @@ -9,7 +9,10 @@ cmake \ -DCMAKE_INSTALL_PREFIX="$EXT_MOUNT/dist" \ -DWHEEL_INSTALL_PREFIX="$EXT_MOUNT/wheels" \ -DBUILD_TESTING=ON \ - -DEVEREST_ENABLE_COMPILE_WARNINGS=ON + -DEVEREST_ENABLE_COMPILE_WARNINGS=ON \ + -DENABLE_GRPC_GENERATOR=ON \ + -DGRPC_EDM=OFF \ + -DGRPC_GENERATOR_EDM=OFF retVal=$? if [ $retVal -ne 0 ]; then echo "Configuring failed with return code $retVal" diff --git a/.ci/build-kit/scripts/create_integration_image.sh b/.ci/build-kit/scripts/create_integration_image.sh index 042f7f6e12..28d0c6efde 100755 --- a/.ci/build-kit/scripts/create_integration_image.sh +++ b/.ci/build-kit/scripts/create_integration_image.sh @@ -8,7 +8,7 @@ if [ $retVal -ne 0 ]; then exit $retVal fi -pip install --break-system-packages \ +python3 -m pip install --break-system-packages \ $EXT_MOUNT/wheels/everestpy-*.whl \ $EXT_MOUNT/wheels/everest_testing-*.whl \ pytest-html diff --git a/.ci/build-kit/scripts/create_ocpp_tests_image.sh b/.ci/build-kit/scripts/create_ocpp_tests_image.sh index db2f25d44e..e823a77ce3 100755 --- a/.ci/build-kit/scripts/create_ocpp_tests_image.sh +++ b/.ci/build-kit/scripts/create_ocpp_tests_image.sh @@ -8,7 +8,7 @@ if [ $retVal -ne 0 ]; then exit $retVal fi -pip install --break-system-packages \ +python3 -m pip install --break-system-packages \ "$EXT_MOUNT"/wheels/everestpy-*.whl \ "$EXT_MOUNT"/wheels/everest_testing-*.whl \ "$EXT_MOUNT"/wheels/iso15118-*.whl \ @@ -20,6 +20,6 @@ if [ $retVal -ne 0 ]; then exit $retVal fi -pip install --break-system-packages -r tests/ocpp_tests/requirements.txt +python3 -m pip install --break-system-packages -r tests/ocpp_tests/requirements.txt $(cd ./tests/ocpp_tests/test_sets/everest-aux/ && ./install_certs.sh "$EXT_MOUNT/dist" && ./install_configs.sh "$EXT_MOUNT/dist") diff --git a/.ci/e2e/scripts/run_integration_tests.sh b/.ci/e2e/scripts/run_integration_tests.sh index 6179499258..97314fdbf7 100755 --- a/.ci/e2e/scripts/run_integration_tests.sh +++ b/.ci/e2e/scripts/run_integration_tests.sh @@ -1,13 +1,14 @@ #!/bin/sh cd tests -pytest \ +python3 -m pytest \ -rA \ --junitxml="$EXT_MOUNT/result.xml" \ --html="$EXT_MOUNT/report.html" \ --self-contained-html \ core_tests/*.py \ framework_tests/*.py \ + eebus_tests/*.py \ --everest-prefix "$EXT_MOUNT/dist" retVal=$? diff --git a/.ci/e2e/scripts/run_ocpp_tests.sh b/.ci/e2e/scripts/run_ocpp_tests.sh index 905626a7e7..8af581308c 100755 --- a/.ci/e2e/scripts/run_ocpp_tests.sh +++ b/.ci/e2e/scripts/run_ocpp_tests.sh @@ -6,7 +6,7 @@ PARALLEL_TESTS=$(nproc) echo "Running $PARALLEL_TESTS ocpp tests in parallel" -pytest \ +python3 -m pytest \ -rA \ -n "$PARALLEL_TESTS" \ --dist=loadgroup \ diff --git a/.github/workflows/build_and_test.yaml b/.github/workflows/build_and_test.yaml index 03fe268b83..57fb6bdb7e 100644 --- a/.github/workflows/build_and_test.yaml +++ b/.github/workflows/build_and_test.yaml @@ -18,7 +18,7 @@ on: jobs: ci: name: Build, Lint and Test - uses: everest/everest-ci/.github/workflows/continuous_integration.yml@v1.4.6 + uses: everest/everest-ci/.github/workflows/continuous_integration.yml@feature/eebus permissions: contents: read secrets: @@ -30,6 +30,7 @@ jobs: do_not_run_coverage_badge_creation: true run_install_wheels: true run_integration_tests: true + build_kit_base_image_tag: feature-eebus ocpp-tests: name: OCPP Tests needs: diff --git a/CMakeLists.txt b/CMakeLists.txt index b39d442c67..6442148d3e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,12 +6,12 @@ project(everest-core LANGUAGES CXX C ) -find_package(everest-cmake 0.5 +find_package(everest-cmake 0.6 COMPONENTS bundling PATHS ../everest-cmake NO_DEFAULT_PATH ) -find_package(everest-cmake 0.5 +find_package(everest-cmake 0.6 COMPONENTS bundling ) @@ -21,7 +21,7 @@ if (NOT everest-cmake_FOUND) FetchContent_Declare( everest-cmake GIT_REPOSITORY https://github.com/EVerest/everest-cmake.git - GIT_TAG main + GIT_TAG v0.6.0 ) FetchContent_MakeAvailable(everest-cmake) set(everest-cmake_DIR "${everest-cmake_SOURCE_DIR}") @@ -65,6 +65,7 @@ option(CREATE_SYMLINKS "Create symlinks to javascript modules and auxillary file option(CMAKE_RUN_CLANG_TIDY "Run clang-tidy" OFF) option(EVEREST_BUILD_API_DOCS "Build EVerest API documentation" OFF) option(ISO15118_2_GENERATE_AND_INSTALL_CERTIFICATES "Automatically generate and install certificates for development purposes" ON) +option(EEBUS_GENERATE_AND_INSTALL_CERTIFICATES "Automatically generate and install certificates for development purposes" ON) option(EVEREST_ENABLE_RUN_SCRIPT_GENERATION "Enables the generation of run scripts (convenience scripts for starting available configurations)" ON) option(${PROJECT_NAME}_BUILD_TESTING "Build unit tests, used if included as dependency" OFF) option(BUILD_TESTING "Build unit tests, used if standalone project" OFF) @@ -124,6 +125,10 @@ if(NOT DISABLE_EDM) # FIXME (aw): this implicit definition for child projects is hacky set(THIRD_PARTY_APP_DST "${CMAKE_INSTALL_LIBEXECDIR}/everest/3rd_party") + if(GRPC_EDM) + enable_language(ASM) + endif() + evc_setup_edm() # FIXME (aw): we need to set this by hand due to edm diff --git a/cmake/external/eebus-grpc.cmake b/cmake/external/eebus-grpc.cmake new file mode 100644 index 0000000000..6593870d2b --- /dev/null +++ b/cmake/external/eebus-grpc.cmake @@ -0,0 +1,132 @@ +include_guard(GLOBAL) + +if (NOT CPM_PACKAGE_eebus-grpc_SOURCE_DIR) + message(FATAL_ERROR "CPM_PACKAGE_eebus-grpc_SOURCE_DIR not set") +endif() + +set(EEBUS_GRPC_API_SOURCE_DIR ${CPM_PACKAGE_eebus-grpc_SOURCE_DIR}) +set(EEBUS_GRPC_API_BINARY_DIR ${CMAKE_BINARY_DIR}/eebus-grpc) + +file(GLOB_RECURSE EEBUS_GRPC_API_SOURCE_FILES + CONFIGURE_DEPENDS + ${EEBUS_GRPC_API_SOURCE_DIR}/* +) + +setup_go() +add_go_target( + NAME + eebus_grpc_api_cmd + OUTPUT + ${EEBUS_GRPC_API_BINARY_DIR}/cmd + GO_PACKAGE_SOURCE_PATH + ${EEBUS_GRPC_API_SOURCE_DIR}/cmd + OUTPUT_DIRECTORY + ${EEBUS_GRPC_API_BINARY_DIR} + WORKING_DIRECTORY + ${EEBUS_GRPC_API_SOURCE_DIR} + DEPENDS + ${EEBUS_GRPC_API_SOURCE_FILES} +) + +add_go_target( + NAME + eebus_grpc_api_create_cert + OUTPUT + ${EEBUS_GRPC_API_BINARY_DIR}/create_cert + GO_PACKAGE_SOURCE_PATH + ${EEBUS_GRPC_API_SOURCE_DIR}/cmd/create_cert + OUTPUT_DIRECTORY + ${EEBUS_GRPC_API_BINARY_DIR} + WORKING_DIRECTORY + ${EEBUS_GRPC_API_SOURCE_DIR} + DEPENDS + ${EEBUS_GRPC_API_SOURCE_FILES} +) + +add_custom_target(eebus_grpc_api_all + DEPENDS + eebus_grpc_api_cmd + eebus_grpc_api_create_cert +) + +install( + FILES + ${EEBUS_GRPC_API_BINARY_DIR}/cmd + DESTINATION + ${CMAKE_INSTALL_PREFIX}/bin + RENAME + eebus_grpc_api + PERMISSIONS + OWNER_EXECUTE OWNER_WRITE OWNER_READ + GROUP_EXECUTE GROUP_READ + WORLD_EXECUTE WORLD_READ +) + +# This function creates certificates for an EEBus component +# +# It will generate thre files: +# - /_cert +# - /_key +# - /_ski +# The generation can be triggered by calling the target +# +function(eebus_create_cert) + set(options) + set(one_value_args + NAME + OUT_DIR + TARGET_NAME + OUT_FILES_VAR + ) + set(multi_value_args) + cmake_parse_arguments(arg "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN}) + + if (arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unparsed arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + if (arg_KEYWORDS_MISSING_VALUES) + message(FATAL_ERROR "Keywords missing values: ${arg_KEYWORDS_MISSING_VALUES}") + endif() + if (NOT arg_NAME) + message(FATAL_ERROR "NAME not set") + endif() + if (NOT arg_OUT_DIR) + message(FATAL_ERROR "OUT_DIR not set") + endif() + if (NOT IS_ABSOLUTE ${arg_OUT_DIR}) + message(FATAL_ERROR "OUT_DIR ${arg_OUT_DIR} is not an absolute path") + endif() + if (NOT arg_TARGET_NAME) + message(FATAL_ERROR "TARGET_NAME not set") + endif() + + get_target_property(CREATE_CERT_BINARY_FILE eebus_grpc_api_create_cert TARGET_FILE) + set(OUT_FILES + ${arg_OUT_DIR}/${arg_NAME}_cert + ${arg_OUT_DIR}/${arg_NAME}_key + ${arg_OUT_DIR}/${arg_NAME}_ski + ) + add_custom_command( + OUTPUT + ${OUT_FILES} + COMMAND + mkdir -p ${arg_OUT_DIR} + COMMAND + ${CREATE_CERT_BINARY_FILE} + ARGS + ${arg_OUT_DIR} + ${arg_NAME} + DEPENDS + eebus_grpc_api_create_cert + COMMENT + "Creating ${arg_NAME} certificates" + ) + add_custom_target(${arg_TARGET_NAME} + DEPENDS + ${OUT_FILES} + ) + + if (arg_OUT_FILES_VAR) + set(${arg_OUT_FILES_VAR} ${OUT_FILES} PARENT_SCOPE) + endif() +endfunction() diff --git a/config/CMakeLists.txt b/config/CMakeLists.txt index eb96b9c690..c7bda1d957 100644 --- a/config/CMakeLists.txt +++ b/config/CMakeLists.txt @@ -20,7 +20,7 @@ generate_config_run_script(CONFIG sil-ocpp-pnc) generate_config_run_script(CONFIG sil-ocpp201-pnc) generate_config_run_script(CONFIG example) generate_config_run_script(CONFIG sil-dc-consumer-api) - +generate_config_run_script(CONFIG eebus) add_subdirectory(bringup) diff --git a/config/config-eebus.yaml b/config/config-eebus.yaml new file mode 100644 index 0000000000..902089f0ea --- /dev/null +++ b/config/config-eebus.yaml @@ -0,0 +1,204 @@ +active_modules: + eebus: + module: EEBUS + connections: + eebus_energy_sink: + - module_id: eebus_energy_sink + implementation_id: external_limits + config_module: + eebus_service_port: 4715 + grpc_port: 50051 + vendor_code: "EVerest" + device_brand: "EVerest" + device_model: "SIL" + serial_number: "123456789" + eebus_ems_ski: "fa2548488be47c89a342ea29c2fc9867df7cf700" + eebus_energy_sink: + module: EnergyNode + config_module: + fuse_limit_A: 32.0 + phase_count: 3 + connections: + energy_consumer: + - implementation_id: energy_grid + module_id: connector_1 + api: + connections: + evse_manager: + - implementation_id: evse + module_id: connector_1 + error_history: + - module_id: error_history + implementation_id: error_history + module: API + error_history: + module: ErrorHistory + config_implementation: + error_history: + database_path: /tmp/error_history.db + auth: + config_module: + connection_timeout: 10 + prioritize_authorization_over_stopping_transaction: true + selection_algorithm: FindFirst + ignore_connector_faults: true + connections: + evse_manager: + - implementation_id: evse + module_id: connector_1 + token_provider: + - implementation_id: main + module_id: token_provider + token_validator: + - implementation_id: main + module_id: token_validator + module: Auth + ev_manager: + config_module: + auto_enable: true + auto_exec: false + auto_exec_commands: sleep 1;iec_wait_pwr_ready;sleep 1;draw_power_regulated 16,3;sleep 30;unplug + connector_id: 1 + connections: + ev: + - implementation_id: ev + module_id: iso15118_car + ev_board_support: + - implementation_id: ev_board_support + module_id: connector_1_powerpath + slac: + - implementation_id: ev + module_id: slac + module: EvManager + energy_manager: + config_module: + switch_3ph1ph_while_charging_mode: Both + switch_3ph1ph_max_nr_of_switches_per_session: 5 + switch_3ph1ph_time_hysteresis_s: 20 + switch_3ph1ph_power_hysteresis_W: 1000 + switch_3ph1ph_switch_limit_stickyness: SinglePhase + schedule_interval_duration: 60 + schedule_total_duration: 10 + debug: false + connections: + energy_trunk: + - implementation_id: energy_grid + module_id: grid_connection_point + module: EnergyManager + connector_1: + config_module: + ac_enforce_hlc: false + ac_hlc_enabled: true + ac_hlc_use_5percent: false + ac_nominal_voltage: 230 + charge_mode: AC + connector_id: 1 + ev_receipt_required: false + evse_id: DE*PNX*E12345*1 + has_ventilation: true + max_current_import_A: 32 + max_current_export_A: 32 + payment_enable_contract: true + payment_enable_eim: true + session_logging: true + session_logging_path: /tmp/everest-logs + session_logging_xml: false + switch_3ph1ph_delay_s: 5 + switch_3ph1ph_cp_state: X1 + connections: + bsp: + - implementation_id: board_support + module_id: connector_1_powerpath + hlc: + - implementation_id: charger + module_id: iso15118_charger + powermeter_grid_side: + - implementation_id: powermeter + module_id: connector_1_powerpath + slac: + - implementation_id: evse + module_id: slac + ac_rcd: + - implementation_id: rcd + module_id: connector_1_powerpath + connector_lock: + - implementation_id: connector_lock + module_id: connector_1_powerpath + module: EvseManager + telemetry: + id: 1 + grid_connection_point: + config_module: + fuse_limit_A: 40 + phase_count: 3 + connections: + energy_consumer: + - implementation_id: energy_grid + module_id: eebus_energy_sink + module: EnergyNode + iso15118_car: + config_module: + device: auto + supported_ISO15118_2: true + connections: {} + module: PyEvJosev + iso15118_charger: + config_module: + device: auto + tls_security: allow + supported_DIN70121: false + connections: {} + module: EvseV2G + connections: + security: + - module_id: evse_security + implementation_id: main + evse_security: + module: EvseSecurity + config_module: + private_key_password: "123456" + persistent_store: + config_module: + sqlite_db_file_path: everest_persistent_store.db + connections: {} + module: PersistentStore + setup: + config_module: + initialized_by_default: true + localization: true + online_check_host: lfenergy.org + setup_simulation: true + setup_wifi: false + connections: + store: + - implementation_id: main + module_id: persistent_store + module: Setup + slac: + module: SlacSimulator + token_provider: + config_implementation: + main: + timeout: 10 + token: DEADBEEF + connections: + evse: + - implementation_id: evse + module_id: connector_1 + module: DummyTokenProvider + token_validator: + config_implementation: + main: + sleep: 0.25 + validation_reason: Token seems valid + validation_result: Accepted + connections: {} + module: DummyTokenValidator + connector_1_powerpath: + config_module: + connector_id: 1 + connections: {} + module: YetiSimulator + telemetry: + id: 1 +x-module-layout: {} diff --git a/dependencies.yaml b/dependencies.yaml index 7218b674e3..b6c0e7831b 100644 --- a/dependencies.yaml +++ b/dependencies.yaml @@ -2,6 +2,10 @@ # For the sake of unambiguity the `git_tag` field is treated as a hash # only if it is 40 characters long hexadecimal string. --- +liblog: + git: https://github.com/EVerest/liblog.git + git_tag: main + options: ["BUILD_EXAMPLES OFF", "CMAKE_POSITION_INDEPENDENT_CODE ON"] everest-framework: git: https://github.com/EVerest/everest-framework.git git_tag: v0.24.0 @@ -132,3 +136,23 @@ mosquitto: - WITH_BROKER OFF - WITH_APPS OFF - WITH_PLUGINS OFF +grpc: + git: https://github.com/grpc/grpc.git + git_tag: v1.71.0 + options: + - gRPC_INSTALL ON + - gRPC_BUILD_GRPC_CSHARP_PLUGIN OFF + - gRPC_BUILD_GRPC_NODE_PLUGIN OFF + - gRPC_BUILD_GRPC_OBJECTIVE_C_PLUGIN OFF + - gRPC_BUILD_GRPC_PHP_PLUGIN OFF + - gRPC_BUILD_GRPC_PYTHON_PLUGIN OFF + - gRPC_BUILD_GRPC_RUBY_PLUGIN OFF + cmake_condition: "EVEREST_DEPENDENCY_ENABLED_GRPC AND GRPC_EDM" +eebus-grpc: + git: https://github.com/enbility/eebus-grpc.git + git_tag: tmp/initial + cmake_condition: "EVEREST_DEPENDENCY_ENABLED_EEBUS_GRPC" +grpc-extended-cpp-plugin: + git: https://github.com/EVerest/grpc-extended-cpp-plugin.git + git_tag: v0.2.0 + cmake_condition: "EVEREST_DEPENDENCY_ENABLED_GRPC_EXTENDED_CPP_PLUGIN AND ENABLE_GRPC_GENERATOR AND GRPC_GENERATOR_EDM" diff --git a/module-dependencies.cmake b/module-dependencies.cmake index e48dd1f170..c8dc350bd1 100644 --- a/module-dependencies.cmake +++ b/module-dependencies.cmake @@ -74,3 +74,20 @@ else() message(STATUS "Dependency everest-gpio NOT enabled") endif() +ev_define_dependency( + DEPENDENCY_NAME grpc + OUTPUT_VARIABLE_SUFFIX GRPC + DEPENDENT_MODULES_LIST EEBUS +) + +ev_define_dependency( + DEPENDENCY_NAME eebus-grpc + OUTPUT_VARIABLE_SUFFIX EEBUS_GRPC + DEPENDENT_MODULES_LIST EEBUS +) + +ev_define_dependency( + DEPENDENCY_NAME grpc-extended-cpp-plugin + OUTPUT_VARIABLE_SUFFIX GRPC_EXTENDED_CPP_PLUGIN + DEPENDENT_MODULES_LIST EEBUS +) diff --git a/modules/EnergyManagement/CMakeLists.txt b/modules/EnergyManagement/CMakeLists.txt index d1ed53c7f8..28c2bb1ac3 100644 --- a/modules/EnergyManagement/CMakeLists.txt +++ b/modules/EnergyManagement/CMakeLists.txt @@ -1,2 +1,3 @@ ev_add_module(EnergyManager) ev_add_module(EnergyNode) +ev_add_module(EEBUS) diff --git a/modules/EnergyManagement/EEBUS/CMakeLists.txt b/modules/EnergyManagement/EEBUS/CMakeLists.txt new file mode 100644 index 0000000000..4d27488fec --- /dev/null +++ b/modules/EnergyManagement/EEBUS/CMakeLists.txt @@ -0,0 +1,61 @@ +# +# AUTO GENERATED - MARKED REGIONS WILL BE KEPT +# template version 3 +# + +# module setup: +# - ${MODULE_NAME}: module name +ev_setup_cpp_module() + +# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1 +include(${CMAKE_SOURCE_DIR}/cmake/external/eebus-grpc.cmake) + +add_subdirectory(grpc_libs) +# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1 + +target_sources(${MODULE_NAME} + PRIVATE + "main/emptyImpl.cpp" +) + +# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1 +target_sources(${MODULE_NAME} + PRIVATE + "helper.cpp" + "ConfigValidator.cpp" + "EebusCallbacks.cpp" + "EebusConnectionHandler.cpp" + "LpcUseCaseHandler.cpp" + "UseCaseEventReader.cpp" +) +target_link_libraries(${MODULE_NAME} + PUBLIC + proto_control_service + proto_cs_lpc_service + everest::run_application +) +add_dependencies(${MODULE_NAME} eebus_grpc_api_cmd) +target_include_directories(${MODULE_NAME} + PRIVATE + ${CMAKE_CURRENT_BINARY_DIR}/generated + ${CMAKE_CURRENT_SOURCE_DIR}/include +) + +get_target_property(EEBUS_GRPC_API_CMD_BINARY_PATH eebus_grpc_api_cmd TARGET_FILE) +install( + FILES + ${EEBUS_GRPC_API_CMD_BINARY_PATH} + DESTINATION + "${EVEREST_MODULE_INSTALL_PREFIX}/${MODULE_NAME}" + RENAME + eebus_grpc_api + PERMISSIONS + OWNER_EXECUTE OWNER_WRITE OWNER_READ + GROUP_EXECUTE GROUP_READ + WORLD_EXECUTE WORLD_READ +) + +if (EEBUS_GENERATE_AND_INSTALL_CERTIFICATES) + include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/eebus-generate-and-install-certificates.cmake) +endif() +# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1 diff --git a/modules/EnergyManagement/EEBUS/ConfigValidator.cpp b/modules/EnergyManagement/EEBUS/ConfigValidator.cpp new file mode 100644 index 0000000000..8739f04d5d --- /dev/null +++ b/modules/EnergyManagement/EEBUS/ConfigValidator.cpp @@ -0,0 +1,198 @@ +#include + +#include "EEBUS.hpp" + +namespace module { + +ConfigValidator::ConfigValidator(const Conf& config, std::filesystem::path etc_prefix, + std::filesystem::path libexec_prefix) : + config(config), + eebus_service_port(config.eebus_service_port), + grpc_port(config.grpc_port), + manage_eebus_grpc_api_binary(config.manage_eebus_grpc_api_binary), + etc_prefix(std::move(etc_prefix)), + libexec_prefix(std::move(libexec_prefix)), + certificate_path(std::filesystem::path(config.certificate_path)), + private_key_path(std::filesystem::path(config.private_key_path)), + eebus_grpc_api_binary_path(std::filesystem::path(config.eebus_grpc_api_binary_path)) { +} + +bool ConfigValidator::validate() { + bool valid = true; + valid &= this->validate_eebus_service_port(); + valid &= this->validate_grpc_port(); + valid &= this->validate_eebus_ems_ski(); + valid &= this->validate_certificate_path(); + valid &= this->validate_private_key_path(); + valid &= this->validate_eebus_grpc_api_binary_path(); + valid &= this->validate_manage_eebus_grpc_api_binary(); + valid &= this->validate_vendor_code(); + valid &= this->validate_device_brand(); + valid &= this->validate_device_model(); + valid &= this->validate_serial_number(); + valid &= this->validate_failsafe_control_limit(); + valid &= this->validate_max_nominal_power(); + return valid; +} + +std::filesystem::path ConfigValidator::get_certificate_path() const { + return this->certificate_path; +} + +std::filesystem::path ConfigValidator::get_private_key_path() const { + return this->private_key_path; +} + +std::filesystem::path ConfigValidator::get_eebus_grpc_api_binary_path() const { + return this->eebus_grpc_api_binary_path; +} + +int ConfigValidator::get_eebus_service_port() const { + return this->eebus_service_port; +} + +int ConfigValidator::get_grpc_port() const { + return this->grpc_port; +} + +std::string ConfigValidator::get_vendor_code() const { + return this->config.vendor_code; +} + +std::string ConfigValidator::get_device_brand() const { + return this->config.device_brand; +} + +std::string ConfigValidator::get_device_model() const { + return this->config.device_model; +} + +std::string ConfigValidator::get_serial_number() const { + return this->config.serial_number; +} + +int ConfigValidator::get_failsafe_control_limit() const { + return this->config.failsafe_control_limit; +} + +int ConfigValidator::get_max_nominal_power() const { + return this->config.max_nominal_power; +} + +bool ConfigValidator::validate_eebus_service_port() const { + if (this->config.eebus_service_port < 0) { + EVLOG_error << "eebus service port is negative"; + return false; + } + return true; +} + +bool ConfigValidator::validate_grpc_port() const { + if (this->config.grpc_port < 0) { + EVLOG_error << "grpc port is negative"; + return false; + } + return true; +} + +std::string ConfigValidator::get_eebus_ems_ski() const { + return this->config.eebus_ems_ski; +} + +bool ConfigValidator::validate_eebus_ems_ski() const { + if (this->config.eebus_ems_ski.empty()) { + EVLOG_error << "EEBUS EMS SKI is empty"; + return false; + } + return true; +} + +bool ConfigValidator::validate_certificate_path() { + if (!this->manage_eebus_grpc_api_binary) { + return true; + } + if (this->certificate_path.is_relative()) { + this->certificate_path = this->etc_prefix / "certs" / this->certificate_path; + EVLOG_info << "Certificate path is relative, using etc prefix: " << this->certificate_path; + } + if (!std::filesystem::exists(this->certificate_path)) { + EVLOG_error << "Certificate file does not exist"; + return false; + } + return true; +} + +bool ConfigValidator::validate_private_key_path() { + if (!this->manage_eebus_grpc_api_binary) { + return true; + } + if (this->private_key_path.is_relative()) { + this->private_key_path = this->etc_prefix / "certs" / this->private_key_path; + EVLOG_info << "Key path is relative, using etc prefix: " << this->private_key_path; + } + if (!std::filesystem::exists(this->private_key_path)) { + EVLOG_error << "Key file does not exist"; + return false; + } + return true; +} + +bool ConfigValidator::validate_eebus_grpc_api_binary_path() { + if (!this->manage_eebus_grpc_api_binary) { + return true; + } + if (this->eebus_grpc_api_binary_path.is_relative()) { + this->eebus_grpc_api_binary_path = this->libexec_prefix / this->eebus_grpc_api_binary_path; + EVLOG_info << "EEBUS GRPC API binary path is relative, using libexec prefix: " + << this->eebus_grpc_api_binary_path; + } + if (!std::filesystem::exists(this->eebus_grpc_api_binary_path)) { + EVLOG_error << "EEBUS GRPC API binary does not exist"; + return false; + } + std::filesystem::perms perms = std::filesystem::status(this->eebus_grpc_api_binary_path).permissions(); + std::filesystem::perms owner_exec_perms = std::filesystem::perms::owner_exec; + if ((perms & owner_exec_perms) == std::filesystem::perms::none) { + EVLOG_error << "EEBUS GRPC API binary is not executable"; + return false; + } + return true; +} + +bool ConfigValidator::validate_manage_eebus_grpc_api_binary() const { + return true; +} + +bool ConfigValidator::validate_vendor_code() const { + return !this->config.vendor_code.empty(); +} + +bool ConfigValidator::validate_device_brand() const { + return !this->config.device_brand.empty(); +} + +bool ConfigValidator::validate_device_model() const { + return !this->config.device_model.empty(); +} + +bool ConfigValidator::validate_serial_number() const { + return !this->config.serial_number.empty(); +} + +bool ConfigValidator::validate_failsafe_control_limit() const { + if (this->config.failsafe_control_limit < 0) { + EVLOG_error << "failsafe_control_limit is negative"; + return false; + } + return true; +} + +bool ConfigValidator::validate_max_nominal_power() const { + if (this->config.max_nominal_power < 0) { + EVLOG_error << "max_nominal_power is negative"; + return false; + } + return true; +} + +} // namespace module diff --git a/modules/EnergyManagement/EEBUS/EEBUS.cpp b/modules/EnergyManagement/EEBUS/EEBUS.cpp new file mode 100644 index 0000000000..8cc1497b27 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/EEBUS.cpp @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#include + +#include +#include + +#include +#include + +#include +#include + +namespace module { + +namespace { +void start_eebus_grpc_api(const std::filesystem::path& binary_path, int port, const std::filesystem::path& cert_file, + const std::filesystem::path& key_file) { + try { + std::vector args; + constexpr int num_args = 6; + args.reserve(num_args); + args.emplace_back("-port"); + args.emplace_back(std::to_string(port)); + args.emplace_back("-certificate-path"); + args.emplace_back(cert_file.string()); + args.emplace_back("-private-key-path"); + args.emplace_back(key_file.string()); + everest::run_application::CmdOutput output = + everest::run_application::run_application(binary_path.string(), args); + EVLOG_info << "eebus-grpc output: " << output.output; + EVLOG_info << "eebus-grpc exit code: " << output.exit_code; + } catch (const std::exception& e) { + EVLOG_critical << "start_eebus_grpc_api thread caught exception: " << e.what(); + } catch (...) { + EVLOG_critical << "start_eebus_grpc_api thread caught unknown exception."; + } +} +} // namespace + +EEBUS::~EEBUS() { + if (this->connection_handler) { + this->connection_handler->stop(); + } + if (this->config.manage_eebus_grpc_api_binary && this->eebus_grpc_api_thread_active.exchange(false)) { + if (this->eebus_grpc_api_thread.joinable()) { + this->eebus_grpc_api_thread.join(); + } + } +} + +void EEBUS::init() { + invoke_init(*p_main); + + // Setup callbacks + this->callbacks.update_limits_callback = [this](types::energy::ExternalLimits new_limits) { + this->r_eebus_energy_sink->call_set_external_limits(std::move(new_limits)); + }; + + auto config_validator = + std::make_shared(this->config, this->info.paths.etc, this->info.paths.libexec); + if (!config_validator->validate()) { + EVLOG_critical << "EEBUS module configuration is invalid"; + return; + } + + if (this->config.manage_eebus_grpc_api_binary) { + if (config_validator->validate()) { + this->eebus_grpc_api_thread_active.store(true); + this->eebus_grpc_api_thread = + std::thread(start_eebus_grpc_api, config_validator->get_eebus_grpc_api_binary_path(), + config_validator->get_grpc_port(), config_validator->get_certificate_path(), + config_validator->get_private_key_path()); + } else { + EVLOG_critical << "Could not validate config for starting eebus_grpc_api binary"; + } + } + + this->connection_handler = std::make_unique(config_validator); + + if (!this->connection_handler->initialize_connection()) { + EVLOG_critical << "Failed to initialize connection to EEBUS service"; + return; + } + + if (!this->connection_handler->add_lpc_use_case(this->callbacks)) { + EVLOG_critical << "Failed to add LPC use case"; + return; + } + + this->connection_handler->subscribe_to_events(); +} + +void EEBUS::ready() { + invoke_ready(*p_main); + if (!this->connection_handler->start_service()) { + EVLOG_critical << "Failed to start EEBUS service"; + return; + } +} + +} // namespace module diff --git a/modules/EnergyManagement/EEBUS/EEBUS.hpp b/modules/EnergyManagement/EEBUS/EEBUS.hpp new file mode 100644 index 0000000000..4ee9a6ef13 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/EEBUS.hpp @@ -0,0 +1,89 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#ifndef EEBUS_HPP +#define EEBUS_HPP + +// +// AUTO GENERATED - MARKED REGIONS WILL BE KEPT +// template version 2 +// + +#include "ld-ev.hpp" + +// headers for provided interface implementations +#include + +// headers for required interface implementations +#include + +// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1 + +#include + +#include +#include +// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1 + +namespace module { + +struct Conf { + bool manage_eebus_grpc_api_binary; + int eebus_service_port; + int grpc_port; + std::string eebus_ems_ski; + std::string certificate_path; + std::string private_key_path; + std::string eebus_grpc_api_binary_path; + std::string vendor_code; + std::string device_brand; + std::string device_model; + std::string serial_number; + int failsafe_control_limit; + int max_nominal_power; +}; + +class EEBUS : public Everest::ModuleBase { +public: + EEBUS() = delete; + EEBUS(const ModuleInfo& info, std::unique_ptr p_main, + std::unique_ptr r_eebus_energy_sink, Conf& config) : + ModuleBase(info), + p_main(std::move(p_main)), + r_eebus_energy_sink(std::move(r_eebus_energy_sink)), + config(config){}; + + const std::unique_ptr p_main; + const std::unique_ptr r_eebus_energy_sink; + const Conf& config; + + // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1 + ~EEBUS() override; + // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1 + +protected: + // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1 + // insert your protected definitions here + // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1 + +private: + friend class LdEverest; + void init(); + void ready(); + + // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1 + std::thread eebus_grpc_api_thread; + std::atomic eebus_grpc_api_thread_active; + + std::unique_ptr connection_handler; + + eebus::EEBusCallbacks callbacks{}; + // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1 +}; + +// ev@087e516b-124c-48df-94fb-109508c7cda9:v1 +// insert other definitions here +// ev@087e516b-124c-48df-94fb-109508c7cda9:v1 + +} // namespace module + +#endif // EEBUS_HPP diff --git a/modules/EnergyManagement/EEBUS/EebusCallbacks.cpp b/modules/EnergyManagement/EEBUS/EebusCallbacks.cpp new file mode 100644 index 0000000000..32806b96e8 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/EebusCallbacks.cpp @@ -0,0 +1,11 @@ +#include + +#include + +namespace module::eebus { + +bool EEBusCallbacks::all_callbacks_valid() const { + return this->update_limits_callback != nullptr; +} + +} // namespace module::eebus diff --git a/modules/EnergyManagement/EEBUS/EebusConnectionHandler.cpp b/modules/EnergyManagement/EEBUS/EebusConnectionHandler.cpp new file mode 100644 index 0000000000..2fb021c332 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/EebusConnectionHandler.cpp @@ -0,0 +1,140 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#include + +#include +#include + +namespace module { + +namespace { +constexpr auto CHANNEL_READY_TIMEOUT = std::chrono::seconds(60); +constexpr auto HEARTBEAT_TIMEOUT_SECONDS = 60; +} // namespace + +EebusConnectionHandler::EebusConnectionHandler(std::shared_ptr config) : config(std::move(config)) { +} + +EebusConnectionHandler::~EebusConnectionHandler() { + this->stop(); +} + +bool EebusConnectionHandler::initialize_connection() { + const auto address = "localhost:" + std::to_string(this->config->get_grpc_port()); + this->control_service_channel = grpc::CreateChannel(address, grpc::InsecureChannelCredentials()); + if (!EebusConnectionHandler::wait_for_channel_ready(this->control_service_channel, CHANNEL_READY_TIMEOUT)) { + EVLOG_error << "Connection to EEBUS gRPC server failed."; + return false; + } + this->control_service_stub = control_service::ControlService::NewStub(this->control_service_channel); + + control_service::SetConfigRequest set_config_request = control_service::CreateSetConfigRequest( + this->config->get_eebus_service_port(), this->config->get_vendor_code(), this->config->get_device_brand(), + this->config->get_device_model(), this->config->get_serial_number(), + {control_service::DeviceCategory_Enum::DeviceCategory_Enum_E_MOBILITY}, + control_service::DeviceType_Enum::DeviceType_Enum_CHARGING_STATION, + {control_service::EntityType_Enum::EntityType_Enum_EVSE}, HEARTBEAT_TIMEOUT_SECONDS); + control_service::EmptyResponse set_config_response; + auto set_config_status = + control_service::CallSetConfig(this->control_service_stub, set_config_request, &set_config_response); + if (!set_config_status.ok()) { + EVLOG_error << "set_config failed: " << set_config_status.error_message(); + return false; + } + + control_service::EmptyRequest start_setup_request; + control_service::EmptyResponse start_setup_response; + auto start_setup_status = + control_service::CallStartSetup(this->control_service_stub, start_setup_request, &start_setup_response); + if (!start_setup_status.ok()) { + EVLOG_warning << "start_setup failed: " << start_setup_status.error_message(); + return false; + } + control_service::RegisterRemoteSkiRequest register_ski_request; + register_ski_request.set_remote_ski(this->config->get_eebus_ems_ski()); + control_service::EmptyResponse register_ski_response; + auto register_ski_status = control_service::CallRegisterRemoteSki(this->control_service_stub, register_ski_request, + ®ister_ski_response); + if (!register_ski_status.ok()) { + EVLOG_error << "register_remote_ski failed: " << register_ski_status.error_message(); + return false; + } + + return true; +} + +bool EebusConnectionHandler::start_service() { + control_service::EmptyRequest request; + control_service::EmptyResponse response; + auto status = control_service::CallStartService(this->control_service_stub, request, &response); + if (!status.ok()) { + EVLOG_error << "start_service failed: " << status.error_message(); + return false; + } + + this->lpc_handler->start(); + + return true; +} + +bool EebusConnectionHandler::add_lpc_use_case(const eebus::EEBusCallbacks& callbacks) { + this->lpc_handler = std::make_unique(this->config, callbacks); + + control_service::UseCase use_case = LpcUseCaseHandler::get_use_case_info(); + common_types::EntityAddress entity_address = common_types::CreateEntityAddress({1}); + control_service::AddUseCaseRequest request = control_service::CreateAddUseCaseRequest(&entity_address, &use_case); + control_service::AddUseCaseResponse response; + auto status = control_service::CallAddUseCase(this->control_service_stub, request, &response); + std::ignore = request.release_entity_address(); + std::ignore = request.release_use_case(); + if (!status.ok() || response.endpoint().empty()) { + EVLOG_error << "add_use_case failed: " << status.error_message(); + return false; + } + + auto lpc_channel = grpc::CreateChannel(response.endpoint(), grpc::InsecureChannelCredentials()); + if (!EebusConnectionHandler::wait_for_channel_ready(lpc_channel, CHANNEL_READY_TIMEOUT)) { + EVLOG_error << "Connection to LPC use case gRPC server failed."; + return false; + } + + this->lpc_handler->set_stub(cs_lpc::ControllableSystemLPCControl::NewStub(lpc_channel)); + this->lpc_handler->configure_use_case(); + + return true; +} + +void EebusConnectionHandler::subscribe_to_events() { + this->event_reader = std::make_unique( + this->control_service_stub, [this](const auto& event) { this->lpc_handler->handle_event(event); }); + + common_types::EntityAddress entity_address = common_types::CreateEntityAddress({1}); + control_service::UseCase use_case = LpcUseCaseHandler::get_use_case_info(); + this->event_reader->start(entity_address, use_case); +} + +void EebusConnectionHandler::stop() { + if (this->event_reader) { + this->event_reader->stop(); + } + if (this->lpc_handler) { + this->lpc_handler->stop(); + } +} + +bool EebusConnectionHandler::wait_for_channel_ready(const std::shared_ptr& channel, + std::chrono::milliseconds timeout) { + auto deadline = std::chrono::system_clock::now() + timeout; + grpc_connectivity_state state = channel->GetState(true); + while (state != GRPC_CHANNEL_READY) { + if (!channel->WaitForStateChange(state, deadline)) { + // timeout or channel is shutting down + EVLOG_error << "Channel is not ready after timeout."; + return false; + } + state = channel->GetState(true); + } + return true; +} + +} // namespace module diff --git a/modules/EnergyManagement/EEBUS/LpcUseCaseHandler.cpp b/modules/EnergyManagement/EEBUS/LpcUseCaseHandler.cpp new file mode 100644 index 0000000000..1148c777ec --- /dev/null +++ b/modules/EnergyManagement/EEBUS/LpcUseCaseHandler.cpp @@ -0,0 +1,380 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#include + +#include +#include + +namespace module { + +namespace { +constexpr auto HEARTBEAT_TIMEOUT = std::chrono::seconds(60); +constexpr auto LPC_TIMEOUT = std::chrono::seconds(120); // Common timeout in spec +} // namespace + +LpcUseCaseHandler::LpcUseCaseHandler(std::shared_ptr config, eebus::EEBusCallbacks callbacks) : + config(std::move(config)), + callbacks(std::move(callbacks)), + state(State::Init), + heartbeat_timeout(HEARTBEAT_TIMEOUT), + failsafe_duration_timeout(std::chrono::hours(2)), // Default to 2 hours, as per spec + failsafe_control_limit(this->config->get_failsafe_control_limit()) { +} + +LpcUseCaseHandler::~LpcUseCaseHandler() { + stop(); +} + +void LpcUseCaseHandler::start() { + this->running = true; + this->init_timestamp = std::chrono::steady_clock::now(); + this->worker_thread = std::thread(&LpcUseCaseHandler::run, this); + this->start_heartbeat(); +} + +void LpcUseCaseHandler::stop() { + if (running.exchange(false)) { + cv.notify_all(); + if (worker_thread.joinable()) { + worker_thread.join(); + } + } +} + +void LpcUseCaseHandler::set_stub(std::shared_ptr stub) { + this->stub = std::move(stub); +} + +void LpcUseCaseHandler::handle_event(const control_service::UseCaseEvent& event) { + std::lock_guard lock(this->queue_mutex); + this->event_queue.push(event); + this->cv.notify_one(); +} + +void LpcUseCaseHandler::run() { + this->set_state(State::Init); + + { + std::lock_guard lock(this->heartbeat_mutex); + this->last_heartbeat_timestamp = std::chrono::steady_clock::now(); // Simulate initial heartbeat + } + + while (this->running) { + std::unique_lock lock(this->queue_mutex); + if (cv.wait_for(lock, std::chrono::seconds(1), [this] { return !this->event_queue.empty(); })) { + // Event received + control_service::UseCaseEvent event = this->event_queue.front(); + this->event_queue.pop(); + lock.unlock(); + + const auto& event_str = event.event(); + + if (event_str == "DataUpdateHeartbeat") { + std::lock_guard heartbeat_lock(this->heartbeat_mutex); + this->last_heartbeat_timestamp = std::chrono::steady_clock::now(); + EVLOG_debug << "Heartbeat received"; + } else if (event_str == "DataUpdateLimit") { + update_limit_from_event(); + } else if (event_str == "DataUpdateFailsafeDurationMinimum") { + cs_lpc::FailsafeDurationMinimumRequest read_duration_req; + cs_lpc::FailsafeDurationMinimumResponse read_duration_res; + auto read_status = + cs_lpc::CallFailsafeDurationMinimum(this->stub, read_duration_req, &read_duration_res); + if (read_status.ok()) { + this->failsafe_duration_timeout = + std::chrono::nanoseconds(read_duration_res.duration_nanoseconds()); + EVLOG_info << "FailsafeDurationMinimum updated to " << read_duration_res.duration_nanoseconds() + << "ns"; + } else { + EVLOG_warning << "Could not re-read FailsafeDurationMinimum after update event: " + << read_status.error_message(); + } + } else if (event_str == "DataUpdateFailsafeConsumptionActivePowerLimit") { + cs_lpc::FailsafeConsumptionActivePowerLimitRequest read_limit_req; + cs_lpc::FailsafeConsumptionActivePowerLimitResponse read_limit_res; + auto read_status = + cs_lpc::CallFailsafeConsumptionActivePowerLimit(this->stub, read_limit_req, &read_limit_res); + if (read_status.ok()) { + this->failsafe_control_limit = read_limit_res.limit(); + EVLOG_info << "FailsafeConsumptionActivePowerLimit updated to " << this->failsafe_control_limit; + } else { + EVLOG_warning << "Could not re-read FailsafeConsumptionActivePowerLimit after update event: " + << read_status.error_message(); + } + } else if (event_str == "WriteApprovalRequired") { + approve_pending_writes(); + } else if (event_str == "UseCaseSupportUpdate") { + // ignore + } else { + EVLOG_error << "Unknown event received: " << event_str; + } + } else { + // Timeout + lock.unlock(); + } + + auto now = std::chrono::steady_clock::now(); + + // Heartbeat check + bool heartbeat_has_timeout = false; + { + std::lock_guard heartbeat_lock(this->heartbeat_mutex); + heartbeat_has_timeout = (now - this->last_heartbeat_timestamp) > this->heartbeat_timeout; + } + std::optional limit; + { + std::lock_guard limit_lock(this->limit_mutex); + limit = this->current_limit; + } + const bool limit_is_active = limit.has_value() && limit.value().is_active(); + const bool limit_is_deactivated = limit.has_value() && !limit.value().is_active(); + const bool limit_expired = + limit.has_value() && !limit->delete_duration() && limit->duration_nanoseconds() != 0 && + now >= (std::chrono::nanoseconds(limit->duration_nanoseconds()) + this->last_limit_received_timestamp); + + switch (this->state.load()) { + case State::Init: + if (heartbeat_has_timeout) { + set_state(State::Failsafe); + break; + } + if ((now - this->init_timestamp) > LPC_TIMEOUT) { + set_state(State::UnlimitedAutonomous); + break; + } + if (limit_is_active) { + set_state(State::Limited); + break; + } + if (limit_is_deactivated) { + set_state(State::UnlimitedControlled); + } + break; + case State::Limited: + if (heartbeat_has_timeout) { + set_state(State::Failsafe); + break; + } + if (limit_is_deactivated or limit_expired) { + set_state(State::UnlimitedControlled); + } + // duration of limit expired, deactivated power limit received -> UnlimitedControlled + break; + case State::UnlimitedControlled: + if (heartbeat_has_timeout) { + set_state(State::Failsafe); + break; + } + if (limit_is_active) { + set_state(State::Limited); + } + break; + case State::UnlimitedAutonomous: + if (heartbeat_has_timeout) { + set_state(State::Failsafe); + break; + } + if (limit_is_deactivated or limit_expired) { + set_state(State::UnlimitedControlled); + break; + } + if (limit_is_active) { + set_state(State::Limited); + } + break; + case State::Failsafe: + // No heartbeat stay in failsafe + if (heartbeat_has_timeout) { + break; + } + // Received heartbeat with a new limit + if (this->last_limit_received_timestamp >= this->failsafe_entry_timestamp) { + if (limit_is_active) { + set_state(State::Limited); + } else if (limit_is_deactivated) { + set_state(State::UnlimitedControlled); + } + break; + } + // Received heartbeat, but no new limit within failsafe duration timeout + 120 seconds spec timeout + if (now > (this->failsafe_entry_timestamp + this->failsafe_duration_timeout + + std::chrono::seconds(LPC_TIMEOUT))) { + set_state(State::UnlimitedAutonomous); + break; + } + break; + } + + const bool state_has_changed = this->state_changed.exchange(false); + const bool limit_has_changed = this->limit_value_changed.exchange(false); + if (state_has_changed || limit_has_changed) { + this->apply_limit_for_current_state(); + } + } +} + +control_service::UseCase LpcUseCaseHandler::get_use_case_info() { + return control_service::CreateUseCase( + control_service::UseCase_ActorType_Enum::UseCase_ActorType_Enum_ControllableSystem, + control_service::UseCase_NameType_Enum::UseCase_NameType_Enum_limitationOfPowerConsumption); +} + +void LpcUseCaseHandler::configure_use_case() { + if (!this->stub) { + return; + } + + cs_lpc::SetConsumptionNominalMaxRequest request1 = + cs_lpc::CreateSetConsumptionNominalMaxRequest(this->config->get_max_nominal_power()); + cs_lpc::SetConsumptionNominalMaxResponse response1; + auto status1 = cs_lpc::CallSetConsumptionNominalMax(this->stub, request1, &response1); + if (!status1.ok()) { + EVLOG_error << "SetConsumptionNominalMax failed: " << status1.error_message(); + } + + common_types::LoadLimit load_limit = + common_types::CreateLoadLimit(0, true, false, this->config->get_max_nominal_power(), false); + cs_lpc::SetConsumptionLimitRequest request2 = cs_lpc::CreateSetConsumptionLimitRequest(&load_limit); + cs_lpc::SetConsumptionLimitResponse response2; + auto status2 = cs_lpc::CallSetConsumptionLimit(this->stub, request2, &response2); + std::ignore = request2.release_load_limit(); + if (!status2.ok()) { + EVLOG_error << "SetConsumptionLimit failed: " << status2.error_message(); + } + + cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest request3 = + cs_lpc::CreateSetFailsafeConsumptionActivePowerLimitRequest(this->config->get_failsafe_control_limit(), true); + cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse response3; + auto status3 = cs_lpc::CallSetFailsafeConsumptionActivePowerLimit(this->stub, request3, &response3); + if (!status3.ok()) { + EVLOG_error << "SetFailsafeConsumptionActivePowerLimit failed: " << status3.error_message(); + } + + cs_lpc::SetFailsafeDurationMinimumRequest request4 = + cs_lpc::CreateSetFailsafeDurationMinimumRequest(7.2e12, true); // 2 hours + cs_lpc::SetFailsafeDurationMinimumResponse response4; + auto status4 = cs_lpc::CallSetFailsafeDurationMinimum(this->stub, request4, &response4); + if (!status4.ok()) { + EVLOG_error << "SetFailsafeDurationMinimum failed: " << status4.error_message(); + } +} + +void LpcUseCaseHandler::approve_pending_writes() { + cs_lpc::PendingConsumptionLimitRequest request = cs_lpc::CreatePendingConsumptionLimitRequest(); + cs_lpc::PendingConsumptionLimitResponse response; + auto status = cs_lpc::CallPendingConsumptionLimit(this->stub, request, &response); + if (!status.ok()) { + EVLOG_error << "PendingConsumptionLimit failed: " << status.error_message(); + return; + } + + for (const auto& entry : response.load_limits()) { + uint64_t msg_counter = entry.first; + cs_lpc::ApproveOrDenyConsumptionLimitRequest approve_request = + cs_lpc::CreateApproveOrDenyConsumptionLimitRequest(msg_counter, true, ""); + cs_lpc::ApproveOrDenyConsumptionLimitResponse approve_response; + auto approve_status = cs_lpc::CallApproveOrDenyConsumptionLimit(this->stub, approve_request, &approve_response); + if (!approve_status.ok()) { + EVLOG_error << "ApproveOrDenyConsumptionLimit failed for msg_counter " << msg_counter << ": " + << approve_status.error_message(); + } + } +} + +void LpcUseCaseHandler::update_limit_from_event() { + cs_lpc::ConsumptionLimitRequest request = cs_lpc::CreateConsumptionLimitRequest(); + cs_lpc::ConsumptionLimitResponse response; + auto status = cs_lpc::CallConsumptionLimit(this->stub, request, &response); + if (!status.ok()) { + EVLOG_error << "ConsumptionLimit failed: " << status.error_message(); + return; + } + { + std::lock_guard lock(this->limit_mutex); + this->current_limit = response.load_limit(); + this->last_limit_received_timestamp = std::chrono::steady_clock::now(); + } + this->limit_value_changed = true; +} + +void LpcUseCaseHandler::start_heartbeat() { + if (!this->stub) { + return; + } + + cs_lpc::StartHeartbeatRequest request; + cs_lpc::StartHeartbeatResponse response; + auto status = cs_lpc::CallStartHeartbeat(this->stub, request, &response); + if (!status.ok()) { + EVLOG_error << "StartHeartbeat failed: " << status.error_message(); + } +} + +void LpcUseCaseHandler::apply_limit_for_current_state() { + types::energy::ExternalLimits limits; + + State state_copy = this->state.load(); + + switch (state_copy) { + case State::Limited: { + std::lock_guard lock(this->limit_mutex); + if (this->current_limit.has_value()) { + limits = translate_to_external_limits(this->current_limit.value()); + } + break; + } + case State::Failsafe: { + common_types::LoadLimit failsafe_limit; + failsafe_limit.set_is_active(true); + failsafe_limit.set_value(this->failsafe_control_limit); + limits = translate_to_external_limits(failsafe_limit); + break; + } + case State::UnlimitedControlled: + case State::UnlimitedAutonomous: { + common_types::LoadLimit unlimited_limit; + unlimited_limit.set_is_active(false); + limits = translate_to_external_limits(unlimited_limit); + break; + } + case State::Init: + // TODO(mlitre): Check what to apply + break; + } + + this->callbacks.update_limits_callback(limits); +} + +void LpcUseCaseHandler::set_state(State new_state) { + State old_state = this->state.load(); + if (old_state != new_state) { + EVLOG_info << "LPC Use Case Handler changing state from " << state_to_string(old_state) << " to " + << state_to_string(new_state); + this->state.store(new_state); + this->state_changed = true; + + if (new_state == State::Failsafe) { + this->failsafe_entry_timestamp = std::chrono::steady_clock::now(); + } + + this->cv.notify_all(); + } +} + +std::string LpcUseCaseHandler::state_to_string(State state) { + switch (state) { + case State::Init: + return "Init"; + case State::UnlimitedControlled: + return "Unlimited/controlled"; + case State::Limited: + return "Limited"; + case State::Failsafe: + return "Failsafe state"; + case State::UnlimitedAutonomous: + return "Unlimited/autonomous"; + } + return "Unknown"; +} + +} // namespace module diff --git a/modules/EnergyManagement/EEBUS/UseCaseEventReader.cpp b/modules/EnergyManagement/EEBUS/UseCaseEventReader.cpp new file mode 100644 index 0000000000..365ab01e24 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/UseCaseEventReader.cpp @@ -0,0 +1,41 @@ +#include + +#include + +#include "common_types/types.pb.h" +#include "control_service/messages.pb.h" + +UseCaseEventReader::UseCaseEventReader(std::shared_ptr stub, + std::function event_callback) : + stub(std::move(stub)), event_callback(std::move(event_callback)) { +} + +void UseCaseEventReader::start(const common_types::EntityAddress& entity_address, + const control_service::UseCase& use_case) { + this->request.mutable_entity_address()->CopyFrom(entity_address); + this->request.mutable_use_case()->CopyFrom(use_case); + this->stub->async()->SubscribeUseCaseEvents(&context, &request, this); + this->StartRead(&this->response); + this->StartCall(); +} + +void UseCaseEventReader::stop() { + this->context.TryCancel(); +} + +void UseCaseEventReader::OnReadDone(bool ok) { + if (ok) { + if (event_callback) { + event_callback(this->response.use_case_event()); + } + StartRead(&this->response); + } +} + +void UseCaseEventReader::OnDone(const grpc::Status& s) { + if (!s.ok()) { + if (s.error_code() != grpc::StatusCode::CANCELLED) { + EVLOG_error << "UseCaseEventReader stream failed: " << s.error_message(); + } + } +} diff --git a/modules/EnergyManagement/EEBUS/cmake/eebus-generate-and-install-certificates.cmake b/modules/EnergyManagement/EEBUS/cmake/eebus-generate-and-install-certificates.cmake new file mode 100644 index 0000000000..bcc624e99f --- /dev/null +++ b/modules/EnergyManagement/EEBUS/cmake/eebus-generate-and-install-certificates.cmake @@ -0,0 +1,16 @@ +add_custom_target(eebus_generate_and_install_certificates ALL) + +eebus_create_cert( + NAME evse + OUT_DIR ${CMAKE_BINARY_DIR}/certs/eebus + TARGET_NAME eebus_evse_cert + OUT_FILES_VAR EEBUS_CERT_FILES +) +add_dependencies(eebus_generate_and_install_certificates eebus_evse_cert) + +install( + FILES + ${EEBUS_CERT_FILES} + DESTINATION + ${CMAKE_INSTALL_SYSCONFDIR}/everest/certs/eebus +) diff --git a/modules/EnergyManagement/EEBUS/doc.rst b/modules/EnergyManagement/EEBUS/doc.rst new file mode 100644 index 0000000000..bb5cb06216 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/doc.rst @@ -0,0 +1,328 @@ +.. _everest_modules_handwritten_EEBUS: + +******************************************* +EEBUS +******************************************* + +:ref:`Link ` to the module's reference. + +This document describes the EVerest EEBUS module. This module acts as a bridge between the EVerest framework and an external EEBUS gRPC service. It implements the "Limitation of Power consumption" (LPC) use case. + +Architecture +============ + +Below is a diagram showing the architecture of the EEBUS module and its interaction with other components. You can render this diagram using a PlantUML renderer. + +.. code-block:: plantuml + + @startuml + !include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml + + title Architecture Diagram for EEBUS Module + + Container(energy_manager, "Energy Manager", "EVerest Module", "Manages energy distribution") + Container(eebus_module, "EEBUS Module", "EVerest C++ Module", "Bridge to EEBUS service for LPC") + System_Ext(eebus_grpc_api, "eebus-grpc-api", "External Go binary, gRPC server/client") + System_Ext(eebus_service, "EEBUS Service (HEMS)", "External System", "Implements EEBUS standard, e.g. LPC") + + Rel(eebus_module, energy_manager, "Publishes ExternalLimits", "everest-interface") + Rel(eebus_module, eebus_grpc_api, "Connects and receives events", "gRPC") + Rel(eebus_grpc_api, eebus_service, "Communicates", "EEBUS (SHIP)") + + @enduml + +How it works +============ + +The module's main class is ``EEBUS``. Its ``init()`` method orchestrates the setup. + +1. **Configuration Validation**: It starts by using ``ConfigValidator`` to check the module's configuration provided in the EVerest ``config.yaml``. This includes validating ports, paths to binaries and certificates, and other parameters. + +2. **gRPC Binary Management**: If ``manage_eebus_grpc_api_binary`` is enabled in the config, the module starts the external ``eebus_grpc_api`` Go binary in a separate thread. This binary acts as a gRPC server for the EVerest module and a client to the actual EEBUS service (e.g., a HEMS). + +3. **Connection Handling**: The ``EebusConnectionHandler`` class is responsible for all gRPC communication. It connects to the ``eebus_grpc_api`` service, sends the device configuration (vendor, brand, model, etc.), and registers the "Limitation of Power Consumption" (LPC) use case. + +4. **Use Case Logic**: For the LPC use case, an ``LpcUseCaseHandler`` is created. This class implements the LPC state machine as defined by the EEBUS specification. + +5. **Event Handling**: To receive events (like new power limits or heartbeats) from the gRPC service, a ``UseCaseEventReader`` is started. It runs in the background, listens for incoming events, and pushes them into a queue within the ``LpcUseCaseHandler``. + +6. **State Machine and Limit Calculation**: The ``LpcUseCaseHandler`` processes these events in a worker thread. Based on the events and its internal state (e.g., ``Limited``, ``Failsafe``), it determines the current power limit. + +7. **Publishing Limits**: The calculated limits are then translated into an EVerest ``ExternalLimits`` schedule using the ``helper::translate_to_external_limits`` function. This schedule is published to the ``EnergyManager`` (or another connected module) via the ``eebus_energy_sink`` required interface. + +State Machine Diagram +===================== + +The following diagram shows the state machine of the `LpcUseCaseHandler`. + +.. code-block:: plantuml + + @startuml + title State Machine for LpcUseCaseHandler + + state "Init" as Init + state "Unlimited / Controlled" as UnlimitedControlled + state "Limited" as Limited + state "Failsafe" as Failsafe + state "Unlimited / Autonomous" as UnlimitedAutonomous + + [*] --> Init + + Init --> Limited : on DataUpdateLimit (active) + Init --> UnlimitedControlled : on DataUpdateLimit (not active) + Init --> UnlimitedAutonomous : on LPC Timeout (120s) + Init --> Failsafe : on Heartbeat Timeout + + Limited --> UnlimitedControlled : on DataUpdateLimit (not active) or Limit expired + Limited --> Failsafe : on Heartbeat Timeout + + UnlimitedControlled --> Limited : on DataUpdateLimit (active) + UnlimitedControlled --> Failsafe : on Heartbeat Timeout + + UnlimitedAutonomous --> Limited : on DataUpdateLimit (active) + UnlimitedAutonomous --> UnlimitedControlled : on DataUpdateLimit (not active) or Limit expired + UnlimitedAutonomous --> Failsafe : on Heartbeat Timeout + + Failsafe --> Limited : on Heartbeat restored AND new active limit received + Failsafe --> UnlimitedControlled : on Heartbeat restored AND new inactive limit received + Failsafe --> UnlimitedAutonomous : on Failsafe Duration Timeout + LPC Timeout + + @enduml + +The handler processes the following events: + +- ``DataUpdateHeartbeat``: A heartbeat from the EEBUS service. If it's missing for a certain time, the handler goes into ``Failsafe`` state. +- ``DataUpdateLimit``: A new power limit from the EEBUS service. +- ``DataUpdateFailsafeDurationMinimum``: Update of the minimum failsafe duration. +- ``DataUpdateFailsafeConsumptionActivePowerLimit``: Update of the failsafe power limit. +- ``WriteApprovalRequired``: The handler needs to approve pending writes from the EEBUS service. + +Based on its state and the received limits, the module publishes ``ExternalLimits`` to the ``eebus_energy_sink``, which is typically connected to an ``EnergyManager`` module. + +Code Flow Diagram +================= + +This sequence diagram illustrates the code flow when an event is received from the EEBUS service. + +.. code-block:: plantuml + + @startuml + title Code Flow Diagram + + participant EEBUS + participant EebusConnectionHandler + participant LpcUseCaseHandler + participant UseCaseEventReader + participant "gRPC Service" as GrpcService + + EEBUS -> EebusConnectionHandler : create + EebusConnectionHandler -> LpcUseCaseHandler : create + EebusConnectionHandler -> UseCaseEventReader : create + EEBUS -> EebusConnectionHandler : initialize_connection() + EEBUS -> EebusConnectionHandler : add_lpc_use_case() + EEBUS -> EebusConnectionHandler : subscribe_to_events() + activate EebusConnectionHandler + EebusConnectionHandler -> UseCaseEventReader : start() + activate UseCaseEventReader + UseCaseEventReader -> GrpcService : SubscribeUseCaseEvents() + deactivate UseCaseEventReader + deactivate EebusConnectionHandler + + EEBUS -> EebusConnectionHandler : start_service() + activate EebusConnectionHandler + EebusConnectionHandler -> LpcUseCaseHandler : start() + activate LpcUseCaseHandler + deactivate LpcUseCaseHandler + deactivate EebusConnectionHandler + + ... event arrives ... + + GrpcService -> UseCaseEventReader : OnReadDone() + activate UseCaseEventReader + UseCaseEventReader -> LpcUseCaseHandler : handle_event(event) + + LpcUseCaseHandler -> LpcUseCaseHandler : push event to queue & notify + deactivate UseCaseEventReader + + LpcUseCaseHandler -> LpcUseCaseHandler : run() loop wakes up + activate LpcUseCaseHandler + LpcUseCaseHandler -> LpcUseCaseHandler : process event, set_state() + LpcUseCaseHandler -> LpcUseCaseHandler : apply_limit_for_current_state() + LpcUseCaseHandler -> EEBUS : callbacks.update_limits_callback() + deactivate LpcUseCaseHandler + + @enduml + +Class Diagram +============= + +This diagram shows the main classes within the EEBUS module and their relationships. + +.. code-block:: plantuml + + @startuml + title Class Diagram for EEBUS Module + + class EEBUS { + + p_main: unique_ptr + + r_eebus_energy_sink: unique_ptr + + config: Conf + - eebus_grpc_api_thread: thread + - connection_handler: unique_ptr + - callbacks: eebus::EEBusCallbacks + + init() + + ready() + } + + class EebusConnectionHandler { + - config: shared_ptr + - lpc_handler: unique_ptr + - event_reader: unique_ptr + - control_service_stub: shared_ptr + + initialize_connection() + + start_service() + + add_lpc_use_case() + + subscribe_to_events() + + stop() + } + + class LpcUseCaseHandler { + - config: shared_ptr + - callbacks: eebus::EEBusCallbacks + - stub: shared_ptr + - state: State + - event_queue: queue + + start() + + stop() + + handle_event() + - run() + - set_state() + - apply_limit_for_current_state() + } + + class UseCaseEventReader { + - stub: shared_ptr + - event_callback: function + + start() + + stop() + + OnReadDone() + } + + class ConfigValidator { + - config: Conf + + validate() + } + + struct Conf { + // ... fields + } + + EEBUS o-- EebusConnectionHandler + EEBUS ..> Conf + EebusConnectionHandler o-- LpcUseCaseHandler + EebusConnectionHandler o-- UseCaseEventReader + EebusConnectionHandler *-- ConfigValidator + LpcUseCaseHandler *-- ConfigValidator + LpcUseCaseHandler ..> eebus.EEBusCallbacks + UseCaseEventReader ..> LpcUseCaseHandler : event_callback + + @enduml + +Configuration +============= + +.. list-table:: + :widths: 25 75 + :header-rows: 1 + + * - Key + - Description + * - ``manage_eebus_grpc_api_binary`` + - (boolean) Whether the module should manage the eebus grpc api binary. Default: ``true`` + * - ``eebus_service_port`` + - (integer) Port for the control service, this will be sent in the SetConfig call. Default: ``4715`` + * - ``grpc_port`` + - (integer) Port for grpc control service connection. This is the port on which we will create our control service channel and start the grpc binary with. Default: ``50051`` + * - ``eebus_ems_ski`` + - (string, required) EEBUS EMS SKI. + * - ``certificate_path`` + - (string) Path to the certificate file used by eebus go client. If relative will be prefixed with everest prefix + etc/everest/certs. Otherwise absolute file path is used. Default: ``eebus/evse_cert`` + * - ``private_key_path`` + - (string) Path to the private key file used by eebus go client. If relative will be prefixed with everest prefix + etc/everest/certs. Otherwise absolute file path is used. Default: ``eebus/evse_key`` + * - ``eebus_grpc_api_binary_path`` + - (string) Path to the eebus grpc api binary. If relative will be prefixed with everest prefix + libexec. Otherwise absolute file path is used. Default: ``eebus_grpc_api`` + * - ``vendor_code`` + - (string, required) Vendor code for the configuration of the control service. + * - ``device_brand`` + - (string, required) Device brand for the configuration of the control service. + * - ``device_model`` + - (string, required) Device model for the configuration of the control service. + * - ``serial_number`` + - (string, required) Serial number for the configuration of the control service. + * - ``failsafe_control_limit`` + - (integer) Failsafe control limit for LPC use case. This will also be used for the default consumption limit, unit is Watts. Default: ``4200`` + * - ``max_nominal_power`` + - (integer) Maximum nominal power of the charging station. This is the max power the CS can consume. Default: ``32000`` + +Provided and required interfaces +================================ + +- Provides ``main`` (``empty`` interface). +- Requires ``eebus_energy_sink`` (``external_energy_limits`` interface). This is used to publish the calculated energy limits. + +Adding a python test +==================== + +The python test suite for the EEBUS module is located in ``tests/eebus_tests``. The tests are written using the ``pytest`` framework. + +To add a new test, you can add a new test function to the ``TestEEBUSModule`` class in ``eebus_tests.py`` or add a new test file. + +A new test function could look like this: + +.. code-block:: python + + @pytest.mark.asyncio + async def test_my_new_feature( + self, + eebus_test_env: dict, + ): + """ + This test verifies my new feature. + """ + # Unpack the test environment from the fixture + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + # Perform the handshake and get the probe module + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # Your test logic here + +The ``eebus_test_env`` fixture provides a dictionary with the necessary components for the test: + +- ``everest_core``: An instance of the ``EverestCore`` class, which manages the EVerest framework. +- ``control_service_servicer``: A mock gRPC control service. +- ``cs_lpc_control_servicer``: A mock gRPC LPC control service. +- ``cs_lpc_control_server``: The gRPC server for the LPC control service. + +The ``perform_eebus_handshake`` helper function can be used to perform the initial handshake between the EEBUS module and the mock gRPC services. + +For new test cases you can create a new class that inherits from ``TestData`` and implement the necessary methods to provide the test data. Then, you can add your new test data to the ``@pytest.mark.parametrize`` decorator in the ``test_set_load_limit`` test function. + +To run the tests, you can use the ``ctest`` command from the build directory. + +Acknowledgment +============== + +This module has thankfully received support from the German Federal Ministry +for Economic Affairs and Climate Action. +Information on the corresponding research project can be found here (in +German only): +`InterBDL research project `_ + +.. image:: https://raw.githubusercontent.com/EVerest/EVerest/main/docs/img/bmwk-logo-incl-supporting.png + :name: bmwk-logo + :align: left + :alt: Supported by Federal Ministry for Economic Affairs and Climate Action. \ No newline at end of file diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/CMakeLists.txt b/modules/EnergyManagement/EEBUS/grpc_libs/CMakeLists.txt new file mode 100644 index 0000000000..3bc1a9128d --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/CMakeLists.txt @@ -0,0 +1,22 @@ +include(${CMAKE_CURRENT_LIST_DIR}/cmake/generate-cpp-from-protobuf.cmake) +include(${CMAKE_CURRENT_LIST_DIR}/cmake/sanity-checks.cmake) +include(${CMAKE_CURRENT_LIST_DIR}/cmake/add-libraries.cmake) + +set(GENERATED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/generated") + +setup_grpc() + +if (ENABLE_GRPC_GENERATOR) + generate_cpp_from_protobuf() +endif() + +add_libraries() + +if (ENABLE_GRPC_GENERATOR) + # Force regeneration, if ENABLE_GRPC_GENERATOR is set + add_dependencies(proto_common_types generate_eebus_grpc_api_proto) + add_dependencies(proto_control_service generate_eebus_grpc_api_proto) + add_dependencies(proto_cs_lpc_service generate_eebus_grpc_api_proto) + + sanity_checks() +endif() diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/cmake/add-libraries.cmake b/modules/EnergyManagement/EEBUS/grpc_libs/cmake/add-libraries.cmake new file mode 100644 index 0000000000..0332f3550d --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/cmake/add-libraries.cmake @@ -0,0 +1,101 @@ +# Adds the library proto_common_types +# Sets the include directories and links the dependencies +macro(_add_proto_common_types_lib) + add_library(proto_common_types + ${GENERATED_DIR}/common_types/types.pb.h + ${GENERATED_DIR}/common_types/types.pb.cc + ${GENERATED_DIR}/common_types/types.grpc.pb.h + ${GENERATED_DIR}/common_types/types.grpc.pb.cc + ${GENERATED_DIR}/common_types/types.grpc-ext.pb.h + ${GENERATED_DIR}/common_types/types.grpc-ext.pb.cc + ) + target_include_directories(proto_common_types + PUBLIC + ${GENERATED_DIR} + ) + target_link_libraries(proto_common_types + PUBLIC + ${COMMON_DEPS} + ) +endmacro() + +# Adds the library proto_control_service +# Sets the include directories and links the dependencies +macro(_add_proto_control_service_lib) + add_library(proto_control_service + ${GENERATED_DIR}/control_service/control_service.pb.h + ${GENERATED_DIR}/control_service/control_service.pb.cc + ${GENERATED_DIR}/control_service/control_service.grpc.pb.h + ${GENERATED_DIR}/control_service/control_service.grpc.pb.cc + ${GENERATED_DIR}/control_service/control_service.grpc-ext.pb.h + ${GENERATED_DIR}/control_service/control_service.grpc-ext.pb.cc + ${GENERATED_DIR}/control_service/messages.pb.h + ${GENERATED_DIR}/control_service/messages.pb.cc + ${GENERATED_DIR}/control_service/messages.grpc.pb.h + ${GENERATED_DIR}/control_service/messages.grpc.pb.cc + ${GENERATED_DIR}/control_service/messages.grpc-ext.pb.h + ${GENERATED_DIR}/control_service/messages.grpc-ext.pb.cc + ${GENERATED_DIR}/control_service/types.pb.h + ${GENERATED_DIR}/control_service/types.pb.cc + ${GENERATED_DIR}/control_service/types.grpc.pb.h + ${GENERATED_DIR}/control_service/types.grpc.pb.cc + ${GENERATED_DIR}/control_service/types.grpc-ext.pb.h + ${GENERATED_DIR}/control_service/types.grpc-ext.pb.cc + ) + target_include_directories(proto_control_service + PUBLIC + ${GENERATED_DIR} + ) + target_link_libraries(proto_control_service + PUBLIC + proto_common_types + ${COMMON_DEPS} + ) +endmacro() + +# Adds the library proto_cs_lpc_service +# Sets the include directories and links the dependencies +macro(_add_proto_cs_lpc_service_lib) + add_library(proto_cs_lpc_service + ${GENERATED_DIR}/usecases/cs/lpc/service.pb.h + ${GENERATED_DIR}/usecases/cs/lpc/service.pb.cc + ${GENERATED_DIR}/usecases/cs/lpc/service.grpc.pb.h + ${GENERATED_DIR}/usecases/cs/lpc/service.grpc.pb.cc + ${GENERATED_DIR}/usecases/cs/lpc/service.grpc-ext.pb.h + ${GENERATED_DIR}/usecases/cs/lpc/service.grpc-ext.pb.cc + ${GENERATED_DIR}/usecases/cs/lpc/messages.pb.h + ${GENERATED_DIR}/usecases/cs/lpc/messages.pb.cc + ${GENERATED_DIR}/usecases/cs/lpc/messages.grpc.pb.h + ${GENERATED_DIR}/usecases/cs/lpc/messages.grpc.pb.cc + ${GENERATED_DIR}/usecases/cs/lpc/messages.grpc-ext.pb.h + ${GENERATED_DIR}/usecases/cs/lpc/messages.grpc-ext.pb.cc + ) + target_include_directories(proto_cs_lpc_service + PUBLIC + ${GENERATED_DIR} + ) + target_link_libraries(proto_cs_lpc_service + PUBLIC + proto_common_types + ${COMMON_DEPS} + ) +endmacro() + +# This macro adds the following libraries: +# - proto_common_types +# - proto_control_service +# - proto_cs_lpc_service +macro(add_libraries) + if(NOT TARGET absl::strings) + message(WARNING "absl::strings not found, is the abseil package installed? Try to find it with 'find_package(absl CONFIG REQUIRED)'") + find_package(absl CONFIG REQUIRED) + endif() + set(COMMON_DEPS + absl::absl_log + gRPC::grpc++ + ) + + _add_proto_common_types_lib() + _add_proto_control_service_lib() + _add_proto_cs_lpc_service_lib() +endmacro() diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/cmake/generate-cpp-from-protobuf.cmake b/modules/EnergyManagement/EEBUS/grpc_libs/cmake/generate-cpp-from-protobuf.cmake new file mode 100644 index 0000000000..c34dbb9a8f --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/cmake/generate-cpp-from-protobuf.cmake @@ -0,0 +1,56 @@ +# This macro generates the C++ files from the protobuf files +# provided by the eebus-grpc package +# The targets generate_proto_common_types, +# generate_proto_control_service and generate_proto_cs_lpc_service +# are added to allow manual generation of the files +macro(generate_cpp_from_protobuf) + if (NOT CPM_PACKAGE_eebus-grpc_SOURCE_DIR) + message(FATAL_ERROR "CPM_PACKAGE_eebus-grpc_SOURCE_DIR not set, it is required becaue it provides the protobuf files") + endif() + get_filename_component(PROTOBUF_DIR + "${CPM_PACKAGE_eebus-grpc_SOURCE_DIR}/protobuf/" + ABSOLUTE + ) + + setup_grpc_generator() + + generate_cpp_from_proto( + TARGET_NAME generate_proto_common_types + PROTOBUF_DIR ${PROTOBUF_DIR} + OUT_DIR ${GENERATED_DIR} + HDRS_VAR COMMON_TYPES_HDRS + SRCS_VAR COMMON_TYPES_SRCS + PROTO_FILES + "${PROTOBUF_DIR}/common_types/types.proto" + ) + + generate_cpp_from_proto( + TARGET_NAME generate_proto_control_service + PROTOBUF_DIR ${PROTOBUF_DIR} + OUT_DIR ${GENERATED_DIR} + HDRS_VAR CONTROL_SERVICE_HDRS + SRCS_VAR CONTROL_SERVICE_SRCS + PROTO_FILES + "${PROTOBUF_DIR}/control_service/control_service.proto" + "${PROTOBUF_DIR}/control_service/messages.proto" + "${PROTOBUF_DIR}/control_service/types.proto" + ) + + generate_cpp_from_proto( + TARGET_NAME generate_proto_cs_lpc_service + PROTOBUF_DIR ${PROTOBUF_DIR} + OUT_DIR ${GENERATED_DIR} + HDRS_VAR CS_LPC_SERVICE_HDRS + SRCS_VAR CS_LPC_SERVICE_SRCS + PROTO_FILES + "${PROTOBUF_DIR}/usecases/cs/lpc/service.proto" + "${PROTOBUF_DIR}/usecases/cs/lpc/messages.proto" + ) + + add_custom_target(generate_eebus_grpc_api_proto + DEPENDS + generate_proto_common_types + generate_proto_control_service + generate_proto_cs_lpc_service + ) +endmacro() diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/cmake/sanity-checks.cmake b/modules/EnergyManagement/EEBUS/grpc_libs/cmake/sanity-checks.cmake new file mode 100644 index 0000000000..0825332313 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/cmake/sanity-checks.cmake @@ -0,0 +1,58 @@ + +# Checks if the files provided by the INCLUDES argument +# are included in the sources of the TARGET +function(_target_includes_check) + set(options) + set(oneValueArgs + TARGET + ) + set(multiValueArgs + INCLUDES + ) + cmake_parse_arguments(arg + "${options}" + "${oneValueArgs}" + "${multiValueArgs}" + ${ARGN} + ) + if (NOT arg_TARGET) + message(FATAL_ERROR "TARGET not set") + endif() + if (NOT TARGET ${arg_TARGET}) + message(FATAL_ERROR "TARGET ${arg_TARGET} not found") + endif() + if (NOT arg_INCLUDES) + message(FATAL_ERROR "INCLUDES not set") + endif() + + get_target_property(TARGET_SOURCES ${arg_TARGET} SOURCES) + foreach(include_file ${arg_INCLUDES}) + if (NOT include_file IN_LIST TARGET_SOURCES) + message(FATAL_ERROR "include file ${include_file} not found in ${arg_TARGET} sources") + endif() + endforeach() +endfunction() + +# Do some sanity checks to ensure that the generated files +# are included in the libraries +macro(sanity_checks) + _target_includes_check( + TARGET proto_common_types + INCLUDES + ${COMMON_TYPES_HDRS} + ${COMMON_TYPES_SRCS} + ) + _target_includes_check( + TARGET proto_control_service + INCLUDES + ${CONTROL_SERVICE_HDRS} + ${CONTROL_SERVICE_SRCS} + ) + _target_includes_check( + TARGET proto_cs_lpc_service + INCLUDES + ${CS_LPC_SERVICE_HDRS} + ${CS_LPC_SERVICE_SRCS} + ) + message(STATUS "Sanity checks passed ✅") +endmacro() diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.cc new file mode 100644 index 0000000000..4ee90e3512 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.cc @@ -0,0 +1,9 @@ +#include "common_types/types.grpc-ext.pb.h" + +#include +#include + +namespace common_types { + +} // namespace common_types + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.h new file mode 100644 index 0000000000..b9b8989e51 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.h @@ -0,0 +1,10 @@ +#ifndef GENERATED_common_types_types_proto_EXT_H +#define GENERATED_common_types_types_proto_EXT_H + +#include "common_types/types.grpc.pb.h" + +namespace common_types { + +} // namespace common_types + +#endif // GENERATED_common_types_types_proto_EXT_H diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.cc new file mode 100644 index 0000000000..3a6ddbcc97 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.cc @@ -0,0 +1,25 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: common_types/types.proto + +#include "common_types/types.pb.h" +#include "common_types/types.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace common_types { + +} // namespace common_types + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.h new file mode 100644 index 0000000000..c842ed3377 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.h @@ -0,0 +1,39 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: common_types/types.proto +// Original file comments: +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +// +#ifndef GRPC_common_5ftypes_2ftypes_2eproto__INCLUDED +#define GRPC_common_5ftypes_2ftypes_2eproto__INCLUDED + +#include "common_types/types.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace common_types { + +} // namespace common_types + + +#include +#endif // GRPC_common_5ftypes_2ftypes_2eproto__INCLUDED diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.cc new file mode 100644 index 0000000000..3cf4224fee --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.cc @@ -0,0 +1,729 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: common_types/types.proto +// Protobuf C++ Version: 5.29.0 + +#include "common_types/types.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace common_types { + +inline constexpr LoadLimit::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : duration_nanoseconds_{::int64_t{0}}, + value_{0}, + is_changeable_{false}, + is_active_{false}, + delete_duration_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR LoadLimit::LoadLimit(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct LoadLimitDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadLimitDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadLimitDefaultTypeInternal() {} + union { + LoadLimit _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadLimitDefaultTypeInternal _LoadLimit_default_instance_; + +inline constexpr EntityAddress::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : entity_address_{}, + _entity_address_cached_byte_size_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR EntityAddress::EntityAddress(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct EntityAddressDefaultTypeInternal { + PROTOBUF_CONSTEXPR EntityAddressDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EntityAddressDefaultTypeInternal() {} + union { + EntityAddress _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EntityAddressDefaultTypeInternal _EntityAddress_default_instance_; +} // namespace common_types +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_common_5ftypes_2ftypes_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_common_5ftypes_2ftypes_2eproto = nullptr; +const ::uint32_t + TableStruct_common_5ftypes_2ftypes_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::common_types::LoadLimit, _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(::common_types::LoadLimit, _impl_.duration_nanoseconds_), + PROTOBUF_FIELD_OFFSET(::common_types::LoadLimit, _impl_.is_changeable_), + PROTOBUF_FIELD_OFFSET(::common_types::LoadLimit, _impl_.is_active_), + PROTOBUF_FIELD_OFFSET(::common_types::LoadLimit, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::common_types::LoadLimit, _impl_.delete_duration_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::common_types::EntityAddress, _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(::common_types::EntityAddress, _impl_.entity_address_), +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::common_types::LoadLimit)}, + {13, -1, -1, sizeof(::common_types::EntityAddress)}, +}; +static const ::_pb::Message* const file_default_instances[] = { + &::common_types::_LoadLimit_default_instance_._instance, + &::common_types::_EntityAddress_default_instance_._instance, +}; +const char descriptor_table_protodef_common_5ftypes_2ftypes_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\030common_types/types.proto\022\014common_types" + "\"{\n\tLoadLimit\022\034\n\024duration_nanoseconds\030\001 " + "\001(\003\022\025\n\ris_changeable\030\002 \001(\010\022\021\n\tis_active\030" + "\003 \001(\010\022\r\n\005value\030\004 \001(\001\022\027\n\017delete_duration\030" + "\005 \001(\010\"\'\n\rEntityAddress\022\026\n\016entity_address" + "\030\001 \003(\rB:Z8github.com/enbility/eebus-grpc" + "/rpc_services/common_typesb\006proto3" +}; +static ::absl::once_flag descriptor_table_common_5ftypes_2ftypes_2eproto_once; +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_common_5ftypes_2ftypes_2eproto = { + false, + false, + 274, + descriptor_table_protodef_common_5ftypes_2ftypes_2eproto, + "common_types/types.proto", + &descriptor_table_common_5ftypes_2ftypes_2eproto_once, + nullptr, + 0, + 2, + schemas, + file_default_instances, + TableStruct_common_5ftypes_2ftypes_2eproto::offsets, + file_level_enum_descriptors_common_5ftypes_2ftypes_2eproto, + file_level_service_descriptors_common_5ftypes_2ftypes_2eproto, +}; +namespace common_types { +// =================================================================== + +class LoadLimit::_Internal { + public: +}; + +LoadLimit::LoadLimit(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:common_types.LoadLimit) +} +LoadLimit::LoadLimit( + ::google::protobuf::Arena* arena, const LoadLimit& from) + : LoadLimit(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE LoadLimit::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void LoadLimit::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, duration_nanoseconds_), + 0, + offsetof(Impl_, delete_duration_) - + offsetof(Impl_, duration_nanoseconds_) + + sizeof(Impl_::delete_duration_)); +} +LoadLimit::~LoadLimit() { + // @@protoc_insertion_point(destructor:common_types.LoadLimit) + SharedDtor(*this); +} +inline void LoadLimit::SharedDtor(MessageLite& self) { + LoadLimit& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* LoadLimit::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) LoadLimit(arena); +} +constexpr auto LoadLimit::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(LoadLimit), + alignof(LoadLimit)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull LoadLimit::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_LoadLimit_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &LoadLimit::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &LoadLimit::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &LoadLimit::ByteSizeLong, + &LoadLimit::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_._cached_size_), + false, + }, + &LoadLimit::kDescriptorMethods, + &descriptor_table_common_5ftypes_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* LoadLimit::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 0, 0, 2> LoadLimit::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::common_types::LoadLimit>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // int64 duration_nanoseconds = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(LoadLimit, _impl_.duration_nanoseconds_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.duration_nanoseconds_)}}, + // bool is_changeable = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.is_changeable_)}}, + // bool is_active = 3; + {::_pbi::TcParser::SingularVarintNoZag1(), + {24, 63, 0, PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.is_active_)}}, + // double value = 4; + {::_pbi::TcParser::FastF64S1, + {33, 63, 0, PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.value_)}}, + // bool delete_duration = 5; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 63, 0, PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.delete_duration_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // int64 duration_nanoseconds = 1; + {PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.duration_nanoseconds_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // bool is_changeable = 2; + {PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.is_changeable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool is_active = 3; + {PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.is_active_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // double value = 4; + {PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.value_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool delete_duration = 5; + {PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.delete_duration_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void LoadLimit::Clear() { +// @@protoc_insertion_point(message_clear_start:common_types.LoadLimit) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.duration_nanoseconds_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.delete_duration_) - + reinterpret_cast(&_impl_.duration_nanoseconds_)) + sizeof(_impl_.delete_duration_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* LoadLimit::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const LoadLimit& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* LoadLimit::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const LoadLimit& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:common_types.LoadLimit) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int64 duration_nanoseconds = 1; + if (this_._internal_duration_nanoseconds() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<1>( + stream, this_._internal_duration_nanoseconds(), target); + } + + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_is_changeable(), target); + } + + // bool is_active = 3; + if (this_._internal_is_active() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 3, this_._internal_is_active(), target); + } + + // double value = 4; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this_._internal_value(), target); + } + + // bool delete_duration = 5; + if (this_._internal_delete_duration() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_delete_duration(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:common_types.LoadLimit) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t LoadLimit::ByteSizeLong(const MessageLite& base) { + const LoadLimit& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t LoadLimit::ByteSizeLong() const { + const LoadLimit& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:common_types.LoadLimit) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // int64 duration_nanoseconds = 1; + if (this_._internal_duration_nanoseconds() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_duration_nanoseconds()); + } + // double value = 4; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + total_size += 9; + } + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + total_size += 2; + } + // bool is_active = 3; + if (this_._internal_is_active() != 0) { + total_size += 2; + } + // bool delete_duration = 5; + if (this_._internal_delete_duration() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void LoadLimit::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:common_types.LoadLimit) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_duration_nanoseconds() != 0) { + _this->_impl_.duration_nanoseconds_ = from._impl_.duration_nanoseconds_; + } + if (::absl::bit_cast<::uint64_t>(from._internal_value()) != 0) { + _this->_impl_.value_ = from._impl_.value_; + } + if (from._internal_is_changeable() != 0) { + _this->_impl_.is_changeable_ = from._impl_.is_changeable_; + } + if (from._internal_is_active() != 0) { + _this->_impl_.is_active_ = from._impl_.is_active_; + } + if (from._internal_delete_duration() != 0) { + _this->_impl_.delete_duration_ = from._impl_.delete_duration_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void LoadLimit::CopyFrom(const LoadLimit& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:common_types.LoadLimit) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void LoadLimit::InternalSwap(LoadLimit* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.delete_duration_) + + sizeof(LoadLimit::_impl_.delete_duration_) + - PROTOBUF_FIELD_OFFSET(LoadLimit, _impl_.duration_nanoseconds_)>( + reinterpret_cast(&_impl_.duration_nanoseconds_), + reinterpret_cast(&other->_impl_.duration_nanoseconds_)); +} + +::google::protobuf::Metadata LoadLimit::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class EntityAddress::_Internal { + public: +}; + +EntityAddress::EntityAddress(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:common_types.EntityAddress) +} +inline PROTOBUF_NDEBUG_INLINE EntityAddress::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::common_types::EntityAddress& from_msg) + : entity_address_{visibility, arena, from.entity_address_}, + _entity_address_cached_byte_size_{0}, + _cached_size_{0} {} + +EntityAddress::EntityAddress( + ::google::protobuf::Arena* arena, + const EntityAddress& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + EntityAddress* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:common_types.EntityAddress) +} +inline PROTOBUF_NDEBUG_INLINE EntityAddress::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : entity_address_{visibility, arena}, + _entity_address_cached_byte_size_{0}, + _cached_size_{0} {} + +inline void EntityAddress::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +EntityAddress::~EntityAddress() { + // @@protoc_insertion_point(destructor:common_types.EntityAddress) + SharedDtor(*this); +} +inline void EntityAddress::SharedDtor(MessageLite& self) { + EntityAddress& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* EntityAddress::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) EntityAddress(arena); +} +constexpr auto EntityAddress::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(EntityAddress, _impl_.entity_address_) + + decltype(EntityAddress::_impl_.entity_address_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(EntityAddress), alignof(EntityAddress), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&EntityAddress::PlacementNew_, + sizeof(EntityAddress), + alignof(EntityAddress)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull EntityAddress::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_EntityAddress_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &EntityAddress::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &EntityAddress::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &EntityAddress::ByteSizeLong, + &EntityAddress::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(EntityAddress, _impl_._cached_size_), + false, + }, + &EntityAddress::kDescriptorMethods, + &descriptor_table_common_5ftypes_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* EntityAddress::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> EntityAddress::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::common_types::EntityAddress>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated uint32 entity_address = 1; + {::_pbi::TcParser::FastV32P1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(EntityAddress, _impl_.entity_address_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated uint32 entity_address = 1; + {PROTOBUF_FIELD_OFFSET(EntityAddress, _impl_.entity_address_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void EntityAddress::Clear() { +// @@protoc_insertion_point(message_clear_start:common_types.EntityAddress) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.entity_address_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* EntityAddress::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const EntityAddress& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* EntityAddress::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const EntityAddress& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:common_types.EntityAddress) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated uint32 entity_address = 1; + { + int byte_size = this_._impl_._entity_address_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 1, this_._internal_entity_address(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:common_types.EntityAddress) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t EntityAddress::ByteSizeLong(const MessageLite& base) { + const EntityAddress& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t EntityAddress::ByteSizeLong() const { + const EntityAddress& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:common_types.EntityAddress) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated uint32 entity_address = 1; + { + total_size += + ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( + this_._internal_entity_address(), 1, + this_._impl_._entity_address_cached_byte_size_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void EntityAddress::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:common_types.EntityAddress) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_entity_address()->MergeFrom(from._internal_entity_address()); + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void EntityAddress::CopyFrom(const EntityAddress& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:common_types.EntityAddress) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void EntityAddress::InternalSwap(EntityAddress* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.entity_address_.InternalSwap(&other->_impl_.entity_address_); +} + +::google::protobuf::Metadata EntityAddress::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +LoadLimit CreateLoadLimit( + int64_t duration_nanoseconds, + bool is_changeable, + bool is_active, + double value, + bool delete_duration) { + LoadLimit res; + res.set_duration_nanoseconds(duration_nanoseconds); + res.set_is_changeable(is_changeable); + res.set_is_active(is_active); + res.set_value(value); + res.set_delete_duration(delete_duration); + return res; +} + +EntityAddress CreateEntityAddress( + std::vector entity_address) { + EntityAddress res; + res.mutable_entity_address()->Add(entity_address.begin(), entity_address.end()); + return res; +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace common_types +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_common_5ftypes_2ftypes_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.h new file mode 100644 index 0000000000..2015a7fbe6 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.h @@ -0,0 +1,709 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: common_types/types.proto +// Protobuf C++ Version: 5.29.0 + +#ifndef common_5ftypes_2ftypes_2eproto_2epb_2eh +#define common_5ftypes_2ftypes_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029000 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_common_5ftypes_2ftypes_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_common_5ftypes_2ftypes_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_common_5ftypes_2ftypes_2eproto; +namespace common_types { +class EntityAddress; +struct EntityAddressDefaultTypeInternal; +extern EntityAddressDefaultTypeInternal _EntityAddress_default_instance_; +class LoadLimit; +struct LoadLimitDefaultTypeInternal; +extern LoadLimitDefaultTypeInternal _LoadLimit_default_instance_; +} // namespace common_types +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace common_types { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class LoadLimit final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:common_types.LoadLimit) */ { + public: + inline LoadLimit() : LoadLimit(nullptr) {} + ~LoadLimit() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(LoadLimit* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(LoadLimit)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR LoadLimit( + ::google::protobuf::internal::ConstantInitialized); + + inline LoadLimit(const LoadLimit& from) : LoadLimit(nullptr, from) {} + inline LoadLimit(LoadLimit&& from) noexcept + : LoadLimit(nullptr, std::move(from)) {} + inline LoadLimit& operator=(const LoadLimit& from) { + CopyFrom(from); + return *this; + } + inline LoadLimit& operator=(LoadLimit&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadLimit& default_instance() { + return *internal_default_instance(); + } + static inline const LoadLimit* internal_default_instance() { + return reinterpret_cast( + &_LoadLimit_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(LoadLimit& a, LoadLimit& b) { a.Swap(&b); } + inline void Swap(LoadLimit* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadLimit* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadLimit* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const LoadLimit& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const LoadLimit& from) { LoadLimit::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(LoadLimit* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "common_types.LoadLimit"; } + + protected: + explicit LoadLimit(::google::protobuf::Arena* arena); + LoadLimit(::google::protobuf::Arena* arena, const LoadLimit& from); + LoadLimit(::google::protobuf::Arena* arena, LoadLimit&& from) noexcept + : LoadLimit(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kDurationNanosecondsFieldNumber = 1, + kValueFieldNumber = 4, + kIsChangeableFieldNumber = 2, + kIsActiveFieldNumber = 3, + kDeleteDurationFieldNumber = 5, + }; + // int64 duration_nanoseconds = 1; + void clear_duration_nanoseconds() ; + ::int64_t duration_nanoseconds() const; + void set_duration_nanoseconds(::int64_t value); + + private: + ::int64_t _internal_duration_nanoseconds() const; + void _internal_set_duration_nanoseconds(::int64_t value); + + public: + // double value = 4; + void clear_value() ; + double value() const; + void set_value(double value); + + private: + double _internal_value() const; + void _internal_set_value(double value); + + public: + // bool is_changeable = 2; + void clear_is_changeable() ; + bool is_changeable() const; + void set_is_changeable(bool value); + + private: + bool _internal_is_changeable() const; + void _internal_set_is_changeable(bool value); + + public: + // bool is_active = 3; + void clear_is_active() ; + bool is_active() const; + void set_is_active(bool value); + + private: + bool _internal_is_active() const; + void _internal_set_is_active(bool value); + + public: + // bool delete_duration = 5; + void clear_delete_duration() ; + bool delete_duration() const; + void set_delete_duration(bool value); + + private: + bool _internal_delete_duration() const; + void _internal_set_delete_duration(bool value); + + public: + // @@protoc_insertion_point(class_scope:common_types.LoadLimit) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 5, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const LoadLimit& from_msg); + ::int64_t duration_nanoseconds_; + double value_; + bool is_changeable_; + bool is_active_; + bool delete_duration_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_common_5ftypes_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class EntityAddress final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:common_types.EntityAddress) */ { + public: + inline EntityAddress() : EntityAddress(nullptr) {} + ~EntityAddress() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(EntityAddress* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(EntityAddress)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR EntityAddress( + ::google::protobuf::internal::ConstantInitialized); + + inline EntityAddress(const EntityAddress& from) : EntityAddress(nullptr, from) {} + inline EntityAddress(EntityAddress&& from) noexcept + : EntityAddress(nullptr, std::move(from)) {} + inline EntityAddress& operator=(const EntityAddress& from) { + CopyFrom(from); + return *this; + } + inline EntityAddress& operator=(EntityAddress&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EntityAddress& default_instance() { + return *internal_default_instance(); + } + static inline const EntityAddress* internal_default_instance() { + return reinterpret_cast( + &_EntityAddress_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(EntityAddress& a, EntityAddress& b) { a.Swap(&b); } + inline void Swap(EntityAddress* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EntityAddress* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EntityAddress* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const EntityAddress& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const EntityAddress& from) { EntityAddress::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(EntityAddress* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "common_types.EntityAddress"; } + + protected: + explicit EntityAddress(::google::protobuf::Arena* arena); + EntityAddress(::google::protobuf::Arena* arena, const EntityAddress& from); + EntityAddress(::google::protobuf::Arena* arena, EntityAddress&& from) noexcept + : EntityAddress(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEntityAddressFieldNumber = 1, + }; + // repeated uint32 entity_address = 1; + int entity_address_size() const; + private: + int _internal_entity_address_size() const; + + public: + void clear_entity_address() ; + ::uint32_t entity_address(int index) const; + void set_entity_address(int index, ::uint32_t value); + void add_entity_address(::uint32_t value); + const ::google::protobuf::RepeatedField<::uint32_t>& entity_address() const; + ::google::protobuf::RepeatedField<::uint32_t>* mutable_entity_address(); + + private: + const ::google::protobuf::RepeatedField<::uint32_t>& _internal_entity_address() const; + ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_entity_address(); + + public: + // @@protoc_insertion_point(class_scope:common_types.EntityAddress) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const EntityAddress& from_msg); + ::google::protobuf::RepeatedField<::uint32_t> entity_address_; + ::google::protobuf::internal::CachedSize _entity_address_cached_byte_size_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_common_5ftypes_2ftypes_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// LoadLimit + +// int64 duration_nanoseconds = 1; +inline void LoadLimit::clear_duration_nanoseconds() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_nanoseconds_ = ::int64_t{0}; +} +inline ::int64_t LoadLimit::duration_nanoseconds() const { + // @@protoc_insertion_point(field_get:common_types.LoadLimit.duration_nanoseconds) + return _internal_duration_nanoseconds(); +} +inline void LoadLimit::set_duration_nanoseconds(::int64_t value) { + _internal_set_duration_nanoseconds(value); + // @@protoc_insertion_point(field_set:common_types.LoadLimit.duration_nanoseconds) +} +inline ::int64_t LoadLimit::_internal_duration_nanoseconds() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.duration_nanoseconds_; +} +inline void LoadLimit::_internal_set_duration_nanoseconds(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_nanoseconds_ = value; +} + +// bool is_changeable = 2; +inline void LoadLimit::clear_is_changeable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = false; +} +inline bool LoadLimit::is_changeable() const { + // @@protoc_insertion_point(field_get:common_types.LoadLimit.is_changeable) + return _internal_is_changeable(); +} +inline void LoadLimit::set_is_changeable(bool value) { + _internal_set_is_changeable(value); + // @@protoc_insertion_point(field_set:common_types.LoadLimit.is_changeable) +} +inline bool LoadLimit::_internal_is_changeable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_changeable_; +} +inline void LoadLimit::_internal_set_is_changeable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = value; +} + +// bool is_active = 3; +inline void LoadLimit::clear_is_active() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_active_ = false; +} +inline bool LoadLimit::is_active() const { + // @@protoc_insertion_point(field_get:common_types.LoadLimit.is_active) + return _internal_is_active(); +} +inline void LoadLimit::set_is_active(bool value) { + _internal_set_is_active(value); + // @@protoc_insertion_point(field_set:common_types.LoadLimit.is_active) +} +inline bool LoadLimit::_internal_is_active() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_active_; +} +inline void LoadLimit::_internal_set_is_active(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_active_ = value; +} + +// double value = 4; +inline void LoadLimit::clear_value() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = 0; +} +inline double LoadLimit::value() const { + // @@protoc_insertion_point(field_get:common_types.LoadLimit.value) + return _internal_value(); +} +inline void LoadLimit::set_value(double value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:common_types.LoadLimit.value) +} +inline double LoadLimit::_internal_value() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.value_; +} +inline void LoadLimit::_internal_set_value(double value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = value; +} + +// bool delete_duration = 5; +inline void LoadLimit::clear_delete_duration() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.delete_duration_ = false; +} +inline bool LoadLimit::delete_duration() const { + // @@protoc_insertion_point(field_get:common_types.LoadLimit.delete_duration) + return _internal_delete_duration(); +} +inline void LoadLimit::set_delete_duration(bool value) { + _internal_set_delete_duration(value); + // @@protoc_insertion_point(field_set:common_types.LoadLimit.delete_duration) +} +inline bool LoadLimit::_internal_delete_duration() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.delete_duration_; +} +inline void LoadLimit::_internal_set_delete_duration(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.delete_duration_ = value; +} + +// ------------------------------------------------------------------- + +// EntityAddress + +// repeated uint32 entity_address = 1; +inline int EntityAddress::_internal_entity_address_size() const { + return _internal_entity_address().size(); +} +inline int EntityAddress::entity_address_size() const { + return _internal_entity_address_size(); +} +inline void EntityAddress::clear_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.entity_address_.Clear(); +} +inline ::uint32_t EntityAddress::entity_address(int index) const { + // @@protoc_insertion_point(field_get:common_types.EntityAddress.entity_address) + return _internal_entity_address().Get(index); +} +inline void EntityAddress::set_entity_address(int index, ::uint32_t value) { + _internal_mutable_entity_address()->Set(index, value); + // @@protoc_insertion_point(field_set:common_types.EntityAddress.entity_address) +} +inline void EntityAddress::add_entity_address(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_entity_address()->Add(value); + // @@protoc_insertion_point(field_add:common_types.EntityAddress.entity_address) +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& EntityAddress::entity_address() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:common_types.EntityAddress.entity_address) + return _internal_entity_address(); +} +inline ::google::protobuf::RepeatedField<::uint32_t>* EntityAddress::mutable_entity_address() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:common_types.EntityAddress.entity_address) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_entity_address(); +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& +EntityAddress::_internal_entity_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.entity_address_; +} +inline ::google::protobuf::RepeatedField<::uint32_t>* EntityAddress::_internal_mutable_entity_address() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.entity_address_; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +LoadLimit CreateLoadLimit( + int64_t duration_nanoseconds, + bool is_changeable, + bool is_active, + double value, + bool delete_duration); + +EntityAddress CreateEntityAddress( + std::vector entity_address); + +// @@protoc_insertion_point(namespace_scope) +} // namespace common_types + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // common_5ftypes_2ftypes_2eproto_2epb_2eh diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.cc new file mode 100644 index 0000000000..b824a4784e --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.cc @@ -0,0 +1,185 @@ +#include "control_service/control_service.grpc-ext.pb.h" + +#include +#include + +namespace control_service { + +grpc::Status CallStartService( + const std::shared_ptr &stub, + control_service::EmptyRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->StartService( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallStopService( + const std::shared_ptr &stub, + control_service::EmptyRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->StopService( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallSetConfig( + const std::shared_ptr &stub, + control_service::SetConfigRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->SetConfig( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallStartSetup( + const std::shared_ptr &stub, + control_service::EmptyRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->StartSetup( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallAddEntity( + const std::shared_ptr &stub, + control_service::AddEntityRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->AddEntity( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallRemoveEntity( + const std::shared_ptr &stub, + control_service::RemoveEntityRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->RemoveEntity( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallRegisterRemoteSki( + const std::shared_ptr &stub, + control_service::RegisterRemoteSkiRequest& request, + control_service::EmptyResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->RegisterRemoteSki( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallAddUseCase( + const std::shared_ptr &stub, + control_service::AddUseCaseRequest& request, + control_service::AddUseCaseResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->AddUseCase( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +} // namespace control_service + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.h new file mode 100644 index 0000000000..f4b6bed533 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.h @@ -0,0 +1,51 @@ +#ifndef GENERATED_control_service_control_service_proto_EXT_H +#define GENERATED_control_service_control_service_proto_EXT_H + +#include "control_service/control_service.grpc.pb.h" +#include "control_service/messages.grpc-ext.pb.h" + +namespace control_service { + +grpc::Status CallStartService( + const std::shared_ptr &stub, + control_service::EmptyRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallStopService( + const std::shared_ptr &stub, + control_service::EmptyRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallSetConfig( + const std::shared_ptr &stub, + control_service::SetConfigRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallStartSetup( + const std::shared_ptr &stub, + control_service::EmptyRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallAddEntity( + const std::shared_ptr &stub, + control_service::AddEntityRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallRemoveEntity( + const std::shared_ptr &stub, + control_service::RemoveEntityRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallRegisterRemoteSki( + const std::shared_ptr &stub, + control_service::RegisterRemoteSkiRequest& request, + control_service::EmptyResponse* response); + +grpc::Status CallAddUseCase( + const std::shared_ptr &stub, + control_service::AddUseCaseRequest& request, + control_service::AddUseCaseResponse* response); + +} // namespace control_service + +#endif // GENERATED_control_service_control_service_proto_EXT_H diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.cc new file mode 100644 index 0000000000..7aeccc4d42 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.cc @@ -0,0 +1,415 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: control_service/control_service.proto + +#include "control_service/control_service.pb.h" +#include "control_service/control_service.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace control_service { + +static const char* ControlService_method_names[] = { + "/control_service.ControlService/StartService", + "/control_service.ControlService/StopService", + "/control_service.ControlService/SetConfig", + "/control_service.ControlService/StartSetup", + "/control_service.ControlService/AddEntity", + "/control_service.ControlService/RemoveEntity", + "/control_service.ControlService/RegisterRemoteSki", + "/control_service.ControlService/AddUseCase", + "/control_service.ControlService/SubscribeUseCaseEvents", +}; + +std::unique_ptr< ControlService::Stub> ControlService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< ControlService::Stub> stub(new ControlService::Stub(channel, options)); + return stub; +} + +ControlService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_StartService_(ControlService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_StopService_(ControlService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SetConfig_(ControlService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_StartSetup_(ControlService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_AddEntity_(ControlService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_RemoveEntity_(ControlService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_RegisterRemoteSki_(ControlService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_AddUseCase_(ControlService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SubscribeUseCaseEvents_(ControlService_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + {} + +::grpc::Status ControlService::Stub::StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartService_, context, request, response); +} + +void ControlService::Stub::async::StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartService_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartService_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncStartServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::EmptyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartService_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncStartServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStartServiceRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StopService_, context, request, response); +} + +void ControlService::Stub::async::StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopService_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopService_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncStopServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::EmptyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StopService_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncStopServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStopServiceRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::SetConfigRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetConfig_, context, request, response); +} + +void ControlService::Stub::async::SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::SetConfigRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetConfig_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetConfig_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncSetConfigRaw(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::SetConfigRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetConfig_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncSetConfigRaw(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetConfigRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartSetup_, context, request, response); +} + +void ControlService::Stub::async::StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartSetup_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartSetup_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncStartSetupRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::EmptyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartSetup_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncStartSetupRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStartSetupRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::AddEntityRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddEntity_, context, request, response); +} + +void ControlService::Stub::async::AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::AddEntityRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddEntity_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddEntity_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncAddEntityRaw(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::AddEntityRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddEntity_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncAddEntityRaw(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncAddEntityRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_RemoveEntity_, context, request, response); +} + +void ControlService::Stub::async::RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_RemoveEntity_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_RemoveEntity_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncRemoveEntityRaw(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::RemoveEntityRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_RemoveEntity_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncRemoveEntityRaw(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncRemoveEntityRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::control_service::EmptyResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_RegisterRemoteSki_, context, request, response); +} + +void ControlService::Stub::async::RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_RegisterRemoteSki_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_RegisterRemoteSki_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::PrepareAsyncRegisterRemoteSkiRaw(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::EmptyResponse, ::control_service::RegisterRemoteSkiRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_RegisterRemoteSki_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* ControlService::Stub::AsyncRegisterRemoteSkiRaw(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncRegisterRemoteSkiRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControlService::Stub::AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::control_service::AddUseCaseResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddUseCase_, context, request, response); +} + +void ControlService::Stub::async::AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddUseCase_, context, request, response, std::move(f)); +} + +void ControlService::Stub::async::AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddUseCase_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>* ControlService::Stub::PrepareAsyncAddUseCaseRaw(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::control_service::AddUseCaseResponse, ::control_service::AddUseCaseRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddUseCase_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>* ControlService::Stub::AsyncAddUseCaseRaw(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncAddUseCaseRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::ClientReader< ::control_service::SubscribeUseCaseEventsResponse>* ControlService::Stub::SubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request) { + return ::grpc::internal::ClientReaderFactory< ::control_service::SubscribeUseCaseEventsResponse>::Create(channel_.get(), rpcmethod_SubscribeUseCaseEvents_, context, request); +} + +void ControlService::Stub::async::SubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest* request, ::grpc::ClientReadReactor< ::control_service::SubscribeUseCaseEventsResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderFactory< ::control_service::SubscribeUseCaseEventsResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeUseCaseEvents_, context, request, reactor); +} + +::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>* ControlService::Stub::AsyncSubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< ::control_service::SubscribeUseCaseEventsResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeUseCaseEvents_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>* ControlService::Stub::PrepareAsyncSubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< ::control_service::SubscribeUseCaseEventsResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeUseCaseEvents_, context, request, false, nullptr); +} + +ControlService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::EmptyRequest* req, + ::control_service::EmptyResponse* resp) { + return service->StartService(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[1], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::EmptyRequest* req, + ::control_service::EmptyResponse* resp) { + return service->StopService(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[2], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::SetConfigRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::SetConfigRequest* req, + ::control_service::EmptyResponse* resp) { + return service->SetConfig(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[3], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::EmptyRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::EmptyRequest* req, + ::control_service::EmptyResponse* resp) { + return service->StartSetup(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[4], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::AddEntityRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::AddEntityRequest* req, + ::control_service::EmptyResponse* resp) { + return service->AddEntity(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[5], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::RemoveEntityRequest* req, + ::control_service::EmptyResponse* resp) { + return service->RemoveEntity(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[6], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::RegisterRemoteSkiRequest* req, + ::control_service::EmptyResponse* resp) { + return service->RegisterRemoteSki(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[7], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControlService::Service, ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::AddUseCaseRequest* req, + ::control_service::AddUseCaseResponse* resp) { + return service->AddUseCase(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControlService_method_names[8], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< ControlService::Service, ::control_service::SubscribeUseCaseEventsRequest, ::control_service::SubscribeUseCaseEventsResponse>( + [](ControlService::Service* service, + ::grpc::ServerContext* ctx, + const ::control_service::SubscribeUseCaseEventsRequest* req, + ::grpc::ServerWriter<::control_service::SubscribeUseCaseEventsResponse>* writer) { + return service->SubscribeUseCaseEvents(ctx, req, writer); + }, this))); +} + +ControlService::Service::~Service() { +} + +::grpc::Status ControlService::Service::StartService(::grpc::ServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::StopService(::grpc::ServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::SetConfig(::grpc::ServerContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::StartSetup(::grpc::ServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::AddEntity(::grpc::ServerContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::RemoveEntity(::grpc::ServerContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::RegisterRemoteSki(::grpc::ServerContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::AddUseCase(::grpc::ServerContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControlService::Service::SubscribeUseCaseEvents(::grpc::ServerContext* context, const ::control_service::SubscribeUseCaseEventsRequest* request, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* writer) { + (void) context; + (void) request; + (void) writer; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace control_service + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.h new file mode 100644 index 0000000000..c00884bceb --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.h @@ -0,0 +1,1531 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: control_service/control_service.proto +// Original file comments: +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +// +#ifndef GRPC_control_5fservice_2fcontrol_5fservice_2eproto__INCLUDED +#define GRPC_control_5fservice_2fcontrol_5fservice_2eproto__INCLUDED + +#include "control_service/control_service.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace control_service { + +class ControlService final { + public: + static constexpr char const* service_full_name() { + return "control_service.ControlService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // Starts the EEBus service + virtual ::grpc::Status StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncStartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncStartServiceRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncStartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncStartServiceRaw(context, request, cq)); + } + // Stops the EEBus service + virtual ::grpc::Status StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncStopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncStopServiceRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncStopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncStopServiceRaw(context, request, cq)); + } + // Set Config for the EEBus service + // Each parameter is optional. If a parameter is not set, the current value is used. + virtual ::grpc::Status SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncSetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncSetConfigRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncSetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncSetConfigRaw(context, request, cq)); + } + // Starts Setup() for the EEBus service + virtual ::grpc::Status StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncStartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncStartSetupRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncStartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncStartSetupRaw(context, request, cq)); + } + // Adds a new entity to the EEBus service + virtual ::grpc::Status AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncAddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncAddEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncAddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncAddEntityRaw(context, request, cq)); + } + // Removes an entity from the EEBus service + virtual ::grpc::Status RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncRemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncRemoveEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncRemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncRemoveEntityRaw(context, request, cq)); + } + // Register remote SKI to the EEBus service + virtual ::grpc::Status RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::control_service::EmptyResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> AsyncRegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(AsyncRegisterRemoteSkiRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>> PrepareAsyncRegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>>(PrepareAsyncRegisterRemoteSkiRaw(context, request, cq)); + } + // Adds an usecase to the EEBus service + virtual ::grpc::Status AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::control_service::AddUseCaseResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::AddUseCaseResponse>> AsyncAddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::AddUseCaseResponse>>(AsyncAddUseCaseRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::AddUseCaseResponse>> PrepareAsyncAddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::control_service::AddUseCaseResponse>>(PrepareAsyncAddUseCaseRaw(context, request, cq)); + } + // Subscribes to usecase events + std::unique_ptr< ::grpc::ClientReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>> SubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>>(SubscribeUseCaseEventsRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>> AsyncSubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>>(AsyncSubscribeUseCaseEventsRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>> PrepareAsyncSubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>>(PrepareAsyncSubscribeUseCaseEventsRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + // Starts the EEBus service + virtual void StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Stops the EEBus service + virtual void StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Set Config for the EEBus service + // Each parameter is optional. If a parameter is not set, the current value is used. + virtual void SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Starts Setup() for the EEBus service + virtual void StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Adds a new entity to the EEBus service + virtual void AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Removes an entity from the EEBus service + virtual void RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Register remote SKI to the EEBus service + virtual void RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response, std::function) = 0; + virtual void RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Adds an usecase to the EEBus service + virtual void AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response, std::function) = 0; + virtual void AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Subscribes to usecase events + virtual void SubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest* request, ::grpc::ClientReadReactor< ::control_service::SubscribeUseCaseEventsResponse>* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncStartServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncStartServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncStopServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncStopServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncSetConfigRaw(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncSetConfigRaw(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncStartSetupRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncStartSetupRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncAddEntityRaw(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncAddEntityRaw(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncRemoveEntityRaw(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncRemoveEntityRaw(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* AsyncRegisterRemoteSkiRaw(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::EmptyResponse>* PrepareAsyncRegisterRemoteSkiRaw(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::AddUseCaseResponse>* AsyncAddUseCaseRaw(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::control_service::AddUseCaseResponse>* PrepareAsyncAddUseCaseRaw(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>* SubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>* AsyncSubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::control_service::SubscribeUseCaseEventsResponse>* PrepareAsyncSubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncStartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncStartServiceRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncStartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncStartServiceRaw(context, request, cq)); + } + ::grpc::Status StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncStopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncStopServiceRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncStopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncStopServiceRaw(context, request, cq)); + } + ::grpc::Status SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncSetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncSetConfigRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncSetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncSetConfigRaw(context, request, cq)); + } + ::grpc::Status StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncStartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncStartSetupRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncStartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncStartSetupRaw(context, request, cq)); + } + ::grpc::Status AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncAddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncAddEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncAddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncAddEntityRaw(context, request, cq)); + } + ::grpc::Status RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncRemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncRemoveEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncRemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncRemoveEntityRaw(context, request, cq)); + } + ::grpc::Status RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::control_service::EmptyResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> AsyncRegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(AsyncRegisterRemoteSkiRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>> PrepareAsyncRegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>>(PrepareAsyncRegisterRemoteSkiRaw(context, request, cq)); + } + ::grpc::Status AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::control_service::AddUseCaseResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>> AsyncAddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>>(AsyncAddUseCaseRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>> PrepareAsyncAddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>>(PrepareAsyncAddUseCaseRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< ::control_service::SubscribeUseCaseEventsResponse>> SubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request) { + return std::unique_ptr< ::grpc::ClientReader< ::control_service::SubscribeUseCaseEventsResponse>>(SubscribeUseCaseEventsRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>> AsyncSubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>>(AsyncSubscribeUseCaseEventsRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>> PrepareAsyncSubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>>(PrepareAsyncSubscribeUseCaseEventsRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void StartService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void StopService(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void SetConfig(::grpc::ClientContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void StartSetup(::grpc::ClientContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void AddEntity(::grpc::ClientContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void RemoveEntity(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response, std::function) override; + void RegisterRemoteSki(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response, std::function) override; + void AddUseCase(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void SubscribeUseCaseEvents(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest* request, ::grpc::ClientReadReactor< ::control_service::SubscribeUseCaseEventsResponse>* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncStartServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncStartServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncStopServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncStopServiceRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncSetConfigRaw(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncSetConfigRaw(::grpc::ClientContext* context, const ::control_service::SetConfigRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncStartSetupRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncStartSetupRaw(::grpc::ClientContext* context, const ::control_service::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncAddEntityRaw(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncAddEntityRaw(::grpc::ClientContext* context, const ::control_service::AddEntityRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncRemoveEntityRaw(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncRemoveEntityRaw(::grpc::ClientContext* context, const ::control_service::RemoveEntityRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* AsyncRegisterRemoteSkiRaw(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::EmptyResponse>* PrepareAsyncRegisterRemoteSkiRaw(::grpc::ClientContext* context, const ::control_service::RegisterRemoteSkiRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>* AsyncAddUseCaseRaw(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::control_service::AddUseCaseResponse>* PrepareAsyncAddUseCaseRaw(::grpc::ClientContext* context, const ::control_service::AddUseCaseRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< ::control_service::SubscribeUseCaseEventsResponse>* SubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request) override; + ::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>* AsyncSubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< ::control_service::SubscribeUseCaseEventsResponse>* PrepareAsyncSubscribeUseCaseEventsRaw(::grpc::ClientContext* context, const ::control_service::SubscribeUseCaseEventsRequest& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_StartService_; + const ::grpc::internal::RpcMethod rpcmethod_StopService_; + const ::grpc::internal::RpcMethod rpcmethod_SetConfig_; + const ::grpc::internal::RpcMethod rpcmethod_StartSetup_; + const ::grpc::internal::RpcMethod rpcmethod_AddEntity_; + const ::grpc::internal::RpcMethod rpcmethod_RemoveEntity_; + const ::grpc::internal::RpcMethod rpcmethod_RegisterRemoteSki_; + const ::grpc::internal::RpcMethod rpcmethod_AddUseCase_; + const ::grpc::internal::RpcMethod rpcmethod_SubscribeUseCaseEvents_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // Starts the EEBus service + virtual ::grpc::Status StartService(::grpc::ServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response); + // Stops the EEBus service + virtual ::grpc::Status StopService(::grpc::ServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response); + // Set Config for the EEBus service + // Each parameter is optional. If a parameter is not set, the current value is used. + virtual ::grpc::Status SetConfig(::grpc::ServerContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response); + // Starts Setup() for the EEBus service + virtual ::grpc::Status StartSetup(::grpc::ServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response); + // Adds a new entity to the EEBus service + virtual ::grpc::Status AddEntity(::grpc::ServerContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response); + // Removes an entity from the EEBus service + virtual ::grpc::Status RemoveEntity(::grpc::ServerContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response); + // Register remote SKI to the EEBus service + virtual ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response); + // Adds an usecase to the EEBus service + virtual ::grpc::Status AddUseCase(::grpc::ServerContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response); + // Subscribes to usecase events + virtual ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* context, const ::control_service::SubscribeUseCaseEventsRequest* request, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* writer); + }; + template + class WithAsyncMethod_StartService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StartService() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_StartService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartService(::grpc::ServerContext* context, ::control_service::EmptyRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StopService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StopService() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_StopService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStopService(::grpc::ServerContext* context, ::control_service::EmptyRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SetConfig : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetConfig() { + ::grpc::Service::MarkMethodAsync(2); + } + ~WithAsyncMethod_SetConfig() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConfig(::grpc::ServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetConfig(::grpc::ServerContext* context, ::control_service::SetConfigRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StartSetup : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StartSetup() { + ::grpc::Service::MarkMethodAsync(3); + } + ~WithAsyncMethod_StartSetup() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartSetup(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartSetup(::grpc::ServerContext* context, ::control_service::EmptyRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_AddEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_AddEntity() { + ::grpc::Service::MarkMethodAsync(4); + } + ~WithAsyncMethod_AddEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddEntity(::grpc::ServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAddEntity(::grpc::ServerContext* context, ::control_service::AddEntityRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_RemoveEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_RemoveEntity() { + ::grpc::Service::MarkMethodAsync(5); + } + ~WithAsyncMethod_RemoveEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RemoveEntity(::grpc::ServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRemoveEntity(::grpc::ServerContext* context, ::control_service::RemoveEntityRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_RegisterRemoteSki : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_RegisterRemoteSki() { + ::grpc::Service::MarkMethodAsync(6); + } + ~WithAsyncMethod_RegisterRemoteSki() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRegisterRemoteSki(::grpc::ServerContext* context, ::control_service::RegisterRemoteSkiRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::EmptyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_AddUseCase : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_AddUseCase() { + ::grpc::Service::MarkMethodAsync(7); + } + ~WithAsyncMethod_AddUseCase() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddUseCase(::grpc::ServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAddUseCase(::grpc::ServerContext* context, ::control_service::AddUseCaseRequest* request, ::grpc::ServerAsyncResponseWriter< ::control_service::AddUseCaseResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SubscribeUseCaseEvents : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SubscribeUseCaseEvents() { + ::grpc::Service::MarkMethodAsync(8); + } + ~WithAsyncMethod_SubscribeUseCaseEvents() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSubscribeUseCaseEvents(::grpc::ServerContext* context, ::control_service::SubscribeUseCaseEventsRequest* request, ::grpc::ServerAsyncWriter< ::control_service::SubscribeUseCaseEventsResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(8, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_StartService > > > > > > > > AsyncService; + template + class WithCallbackMethod_StartService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StartService() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::EmptyRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response) { return this->StartService(context, request, response); }));} + void SetMessageAllocatorFor_StartService( + ::grpc::MessageAllocator< ::control_service::EmptyRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::EmptyRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StartService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StartService( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_StopService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StopService() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::EmptyRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response) { return this->StopService(context, request, response); }));} + void SetMessageAllocatorFor_StopService( + ::grpc::MessageAllocator< ::control_service::EmptyRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::EmptyRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StopService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StopService( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SetConfig : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetConfig() { + ::grpc::Service::MarkMethodCallback(2, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::SetConfigRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::SetConfigRequest* request, ::control_service::EmptyResponse* response) { return this->SetConfig(context, request, response); }));} + void SetMessageAllocatorFor_SetConfig( + ::grpc::MessageAllocator< ::control_service::SetConfigRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::SetConfigRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetConfig() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConfig(::grpc::ServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetConfig( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_StartSetup : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StartSetup() { + ::grpc::Service::MarkMethodCallback(3, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::EmptyRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::EmptyRequest* request, ::control_service::EmptyResponse* response) { return this->StartSetup(context, request, response); }));} + void SetMessageAllocatorFor_StartSetup( + ::grpc::MessageAllocator< ::control_service::EmptyRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::EmptyRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StartSetup() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartSetup(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StartSetup( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_AddEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_AddEntity() { + ::grpc::Service::MarkMethodCallback(4, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::AddEntityRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::AddEntityRequest* request, ::control_service::EmptyResponse* response) { return this->AddEntity(context, request, response); }));} + void SetMessageAllocatorFor_AddEntity( + ::grpc::MessageAllocator< ::control_service::AddEntityRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::AddEntityRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_AddEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddEntity(::grpc::ServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* AddEntity( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_RemoveEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_RemoveEntity() { + ::grpc::Service::MarkMethodCallback(5, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::RemoveEntityRequest* request, ::control_service::EmptyResponse* response) { return this->RemoveEntity(context, request, response); }));} + void SetMessageAllocatorFor_RemoveEntity( + ::grpc::MessageAllocator< ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_RemoveEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RemoveEntity(::grpc::ServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* RemoveEntity( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_RegisterRemoteSki : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_RegisterRemoteSki() { + ::grpc::Service::MarkMethodCallback(6, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::RegisterRemoteSkiRequest* request, ::control_service::EmptyResponse* response) { return this->RegisterRemoteSki(context, request, response); }));} + void SetMessageAllocatorFor_RegisterRemoteSki( + ::grpc::MessageAllocator< ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_RegisterRemoteSki() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* RegisterRemoteSki( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_AddUseCase : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_AddUseCase() { + ::grpc::Service::MarkMethodCallback(7, + new ::grpc::internal::CallbackUnaryHandler< ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::AddUseCaseRequest* request, ::control_service::AddUseCaseResponse* response) { return this->AddUseCase(context, request, response); }));} + void SetMessageAllocatorFor_AddUseCase( + ::grpc::MessageAllocator< ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); + static_cast<::grpc::internal::CallbackUnaryHandler< ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_AddUseCase() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddUseCase(::grpc::ServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* AddUseCase( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SubscribeUseCaseEvents : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SubscribeUseCaseEvents() { + ::grpc::Service::MarkMethodCallback(8, + new ::grpc::internal::CallbackServerStreamingHandler< ::control_service::SubscribeUseCaseEventsRequest, ::control_service::SubscribeUseCaseEventsResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::control_service::SubscribeUseCaseEventsRequest* request) { return this->SubscribeUseCaseEvents(context, request); })); + } + ~WithCallbackMethod_SubscribeUseCaseEvents() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::control_service::SubscribeUseCaseEventsResponse>* SubscribeUseCaseEvents( + ::grpc::CallbackServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/) { return nullptr; } + }; + typedef WithCallbackMethod_StartService > > > > > > > > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_StartService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StartService() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_StartService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_StopService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StopService() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_StopService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SetConfig : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetConfig() { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_SetConfig() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConfig(::grpc::ServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_StartSetup : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StartSetup() { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_StartSetup() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartSetup(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_AddEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_AddEntity() { + ::grpc::Service::MarkMethodGeneric(4); + } + ~WithGenericMethod_AddEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddEntity(::grpc::ServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_RemoveEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_RemoveEntity() { + ::grpc::Service::MarkMethodGeneric(5); + } + ~WithGenericMethod_RemoveEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RemoveEntity(::grpc::ServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_RegisterRemoteSki : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_RegisterRemoteSki() { + ::grpc::Service::MarkMethodGeneric(6); + } + ~WithGenericMethod_RegisterRemoteSki() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_AddUseCase : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_AddUseCase() { + ::grpc::Service::MarkMethodGeneric(7); + } + ~WithGenericMethod_AddUseCase() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddUseCase(::grpc::ServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SubscribeUseCaseEvents : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SubscribeUseCaseEvents() { + ::grpc::Service::MarkMethodGeneric(8); + } + ~WithGenericMethod_SubscribeUseCaseEvents() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_StartService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StartService() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_StartService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartService(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StopService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StopService() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_StopService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStopService(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SetConfig : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetConfig() { + ::grpc::Service::MarkMethodRaw(2); + } + ~WithRawMethod_SetConfig() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConfig(::grpc::ServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetConfig(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartSetup : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StartSetup() { + ::grpc::Service::MarkMethodRaw(3); + } + ~WithRawMethod_StartSetup() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartSetup(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartSetup(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_AddEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_AddEntity() { + ::grpc::Service::MarkMethodRaw(4); + } + ~WithRawMethod_AddEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddEntity(::grpc::ServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAddEntity(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_RemoveEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_RemoveEntity() { + ::grpc::Service::MarkMethodRaw(5); + } + ~WithRawMethod_RemoveEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RemoveEntity(::grpc::ServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRemoveEntity(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_RegisterRemoteSki : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_RegisterRemoteSki() { + ::grpc::Service::MarkMethodRaw(6); + } + ~WithRawMethod_RegisterRemoteSki() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRegisterRemoteSki(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_AddUseCase : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_AddUseCase() { + ::grpc::Service::MarkMethodRaw(7); + } + ~WithRawMethod_AddUseCase() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddUseCase(::grpc::ServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAddUseCase(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SubscribeUseCaseEvents : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SubscribeUseCaseEvents() { + ::grpc::Service::MarkMethodRaw(8); + } + ~WithRawMethod_SubscribeUseCaseEvents() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSubscribeUseCaseEvents(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(8, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_StartService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StartService() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->StartService(context, request, response); })); + } + ~WithRawCallbackMethod_StartService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StartService( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_StopService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StopService() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->StopService(context, request, response); })); + } + ~WithRawCallbackMethod_StopService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StopService( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SetConfig : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetConfig() { + ::grpc::Service::MarkMethodRawCallback(2, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetConfig(context, request, response); })); + } + ~WithRawCallbackMethod_SetConfig() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConfig(::grpc::ServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetConfig( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_StartSetup : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StartSetup() { + ::grpc::Service::MarkMethodRawCallback(3, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->StartSetup(context, request, response); })); + } + ~WithRawCallbackMethod_StartSetup() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartSetup(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StartSetup( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_AddEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_AddEntity() { + ::grpc::Service::MarkMethodRawCallback(4, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AddEntity(context, request, response); })); + } + ~WithRawCallbackMethod_AddEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddEntity(::grpc::ServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* AddEntity( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_RemoveEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_RemoveEntity() { + ::grpc::Service::MarkMethodRawCallback(5, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->RemoveEntity(context, request, response); })); + } + ~WithRawCallbackMethod_RemoveEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RemoveEntity(::grpc::ServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* RemoveEntity( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_RegisterRemoteSki : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_RegisterRemoteSki() { + ::grpc::Service::MarkMethodRawCallback(6, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->RegisterRemoteSki(context, request, response); })); + } + ~WithRawCallbackMethod_RegisterRemoteSki() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* RegisterRemoteSki( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_AddUseCase : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_AddUseCase() { + ::grpc::Service::MarkMethodRawCallback(7, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AddUseCase(context, request, response); })); + } + ~WithRawCallbackMethod_AddUseCase() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddUseCase(::grpc::ServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* AddUseCase( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SubscribeUseCaseEvents : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SubscribeUseCaseEvents() { + ::grpc::Service::MarkMethodRawCallback(8, + new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->SubscribeUseCaseEvents(context, request); })); + } + ~WithRawCallbackMethod_SubscribeUseCaseEvents() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* SubscribeUseCaseEvents( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_StartService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_StartService() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::EmptyRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::EmptyRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedStartService(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_StartService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StartService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStartService(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::EmptyRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_StopService : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_StopService() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::EmptyRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::EmptyRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedStopService(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_StopService() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StopService(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStopService(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::EmptyRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SetConfig : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetConfig() { + ::grpc::Service::MarkMethodStreamed(2, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::SetConfigRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::SetConfigRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedSetConfig(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetConfig() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetConfig(::grpc::ServerContext* /*context*/, const ::control_service::SetConfigRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetConfig(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::SetConfigRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_StartSetup : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_StartSetup() { + ::grpc::Service::MarkMethodStreamed(3, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::EmptyRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::EmptyRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedStartSetup(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_StartSetup() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StartSetup(::grpc::ServerContext* /*context*/, const ::control_service::EmptyRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStartSetup(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::EmptyRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_AddEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_AddEntity() { + ::grpc::Service::MarkMethodStreamed(4, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::AddEntityRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::AddEntityRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedAddEntity(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_AddEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status AddEntity(::grpc::ServerContext* /*context*/, const ::control_service::AddEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedAddEntity(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::AddEntityRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_RemoveEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_RemoveEntity() { + ::grpc::Service::MarkMethodStreamed(5, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::RemoveEntityRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedRemoveEntity(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_RemoveEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status RemoveEntity(::grpc::ServerContext* /*context*/, const ::control_service::RemoveEntityRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedRemoveEntity(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::RemoveEntityRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_RegisterRemoteSki : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_RegisterRemoteSki() { + ::grpc::Service::MarkMethodStreamed(6, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::RegisterRemoteSkiRequest, ::control_service::EmptyResponse>* streamer) { + return this->StreamedRegisterRemoteSki(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_RegisterRemoteSki() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status RegisterRemoteSki(::grpc::ServerContext* /*context*/, const ::control_service::RegisterRemoteSkiRequest* /*request*/, ::control_service::EmptyResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedRegisterRemoteSki(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::RegisterRemoteSkiRequest,::control_service::EmptyResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_AddUseCase : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_AddUseCase() { + ::grpc::Service::MarkMethodStreamed(7, + new ::grpc::internal::StreamedUnaryHandler< + ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::control_service::AddUseCaseRequest, ::control_service::AddUseCaseResponse>* streamer) { + return this->StreamedAddUseCase(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_AddUseCase() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status AddUseCase(::grpc::ServerContext* /*context*/, const ::control_service::AddUseCaseRequest* /*request*/, ::control_service::AddUseCaseResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedAddUseCase(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::control_service::AddUseCaseRequest,::control_service::AddUseCaseResponse>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_StartService > > > > > > > StreamedUnaryService; + template + class WithSplitStreamingMethod_SubscribeUseCaseEvents : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithSplitStreamingMethod_SubscribeUseCaseEvents() { + ::grpc::Service::MarkMethodStreamed(8, + new ::grpc::internal::SplitServerStreamingHandler< + ::control_service::SubscribeUseCaseEventsRequest, ::control_service::SubscribeUseCaseEventsResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerSplitStreamer< + ::control_service::SubscribeUseCaseEventsRequest, ::control_service::SubscribeUseCaseEventsResponse>* streamer) { + return this->StreamedSubscribeUseCaseEvents(context, + streamer); + })); + } + ~WithSplitStreamingMethod_SubscribeUseCaseEvents() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SubscribeUseCaseEvents(::grpc::ServerContext* /*context*/, const ::control_service::SubscribeUseCaseEventsRequest* /*request*/, ::grpc::ServerWriter< ::control_service::SubscribeUseCaseEventsResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedSubscribeUseCaseEvents(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::control_service::SubscribeUseCaseEventsRequest,::control_service::SubscribeUseCaseEventsResponse>* server_split_streamer) = 0; + }; + typedef WithSplitStreamingMethod_SubscribeUseCaseEvents SplitStreamedService; + typedef WithStreamedUnaryMethod_StartService > > > > > > > > StreamedService; +}; + +} // namespace control_service + + +#include +#endif // GRPC_control_5fservice_2fcontrol_5fservice_2eproto__INCLUDED diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.cc new file mode 100644 index 0000000000..ca1942ded9 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.cc @@ -0,0 +1,97 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: control_service/control_service.proto +// Protobuf C++ Version: 5.29.0 + +#include "control_service/control_service.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace control_service { +} // namespace control_service +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_control_5fservice_2fcontrol_5fservice_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_control_5fservice_2fcontrol_5fservice_2eproto = nullptr; +const ::uint32_t TableStruct_control_5fservice_2fcontrol_5fservice_2eproto::offsets[1] = {}; +static constexpr ::_pbi::MigrationSchema* schemas = nullptr; +static constexpr ::_pb::Message* const* file_default_instances = nullptr; +const char descriptor_table_protodef_control_5fservice_2fcontrol_5fservice_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n%control_service/control_service.proto\022" + "\017control_service\032\036control_service/messag" + "es.proto2\266\006\n\016ControlService\022O\n\014StartServ" + "ice\022\035.control_service.EmptyRequest\032\036.con" + "trol_service.EmptyResponse\"\000\022N\n\013StopServ" + "ice\022\035.control_service.EmptyRequest\032\036.con" + "trol_service.EmptyResponse\"\000\022P\n\tSetConfi" + "g\022!.control_service.SetConfigRequest\032\036.c" + "ontrol_service.EmptyResponse\"\000\022M\n\nStartS" + "etup\022\035.control_service.EmptyRequest\032\036.co" + "ntrol_service.EmptyResponse\"\000\022P\n\tAddEnti" + "ty\022!.control_service.AddEntityRequest\032\036." + "control_service.EmptyResponse\"\000\022V\n\014Remov" + "eEntity\022$.control_service.RemoveEntityRe" + "quest\032\036.control_service.EmptyResponse\"\000\022" + "`\n\021RegisterRemoteSki\022).control_service.R" + "egisterRemoteSkiRequest\032\036.control_servic" + "e.EmptyResponse\"\000\022W\n\nAddUseCase\022\".contro" + "l_service.AddUseCaseRequest\032#.control_se" + "rvice.AddUseCaseResponse\"\000\022}\n\026SubscribeU" + "seCaseEvents\022..control_service.Subscribe" + "UseCaseEventsRequest\032/.control_service.S" + "ubscribeUseCaseEventsResponse\"\0000\001B=Z;git" + "hub.com/enbility/eebus-grpc/rpc_services" + "/control_serviceb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto_deps[1] = + { + &::descriptor_table_control_5fservice_2fmessages_2eproto, +}; +static ::absl::once_flag descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto_once; +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto = { + false, + false, + 984, + descriptor_table_protodef_control_5fservice_2fcontrol_5fservice_2eproto, + "control_service/control_service.proto", + &descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto_once, + descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto_deps, + 1, + 0, + schemas, + file_default_instances, + TableStruct_control_5fservice_2fcontrol_5fservice_2eproto::offsets, + file_level_enum_descriptors_control_5fservice_2fcontrol_5fservice_2eproto, + file_level_service_descriptors_control_5fservice_2fcontrol_5fservice_2eproto, +}; +namespace control_service { +// @@protoc_insertion_point(namespace_scope) +} // namespace control_service +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.h new file mode 100644 index 0000000000..c7d4c34ba1 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.h @@ -0,0 +1,87 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: control_service/control_service.proto +// Protobuf C++ Version: 5.29.0 + +#ifndef control_5fservice_2fcontrol_5fservice_2eproto_2epb_2eh +#define control_5fservice_2fcontrol_5fservice_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029000 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "control_service/messages.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_control_5fservice_2fcontrol_5fservice_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_control_5fservice_2fcontrol_5fservice_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_control_5fservice_2fcontrol_5fservice_2eproto; +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace control_service { + +// =================================================================== + + + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace control_service + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // control_5fservice_2fcontrol_5fservice_2eproto_2epb_2eh diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.cc new file mode 100644 index 0000000000..3445dabcdb --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.cc @@ -0,0 +1,9 @@ +#include "control_service/messages.grpc-ext.pb.h" + +#include +#include + +namespace control_service { + +} // namespace control_service + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.h new file mode 100644 index 0000000000..7ae444aa41 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.h @@ -0,0 +1,12 @@ +#ifndef GENERATED_control_service_messages_proto_EXT_H +#define GENERATED_control_service_messages_proto_EXT_H + +#include "control_service/messages.grpc.pb.h" +#include "control_service/types.grpc-ext.pb.h" +#include "common_types/types.grpc-ext.pb.h" + +namespace control_service { + +} // namespace control_service + +#endif // GENERATED_control_service_messages_proto_EXT_H diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.cc new file mode 100644 index 0000000000..41a3f8bb31 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.cc @@ -0,0 +1,25 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: control_service/messages.proto + +#include "control_service/messages.pb.h" +#include "control_service/messages.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace control_service { + +} // namespace control_service + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.h new file mode 100644 index 0000000000..3f34bf2b16 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.h @@ -0,0 +1,39 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: control_service/messages.proto +// Original file comments: +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +// +#ifndef GRPC_control_5fservice_2fmessages_2eproto__INCLUDED +#define GRPC_control_5fservice_2fmessages_2eproto__INCLUDED + +#include "control_service/messages.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace control_service { + +} // namespace control_service + + +#include +#endif // GRPC_control_5fservice_2fmessages_2eproto__INCLUDED diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.cc new file mode 100644 index 0000000000..4fc93ec271 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.cc @@ -0,0 +1,3263 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: control_service/messages.proto +// Protobuf C++ Version: 5.29.0 + +#include "control_service/messages.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace control_service { + +inline constexpr SetConfigRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : device_categories_{}, + _device_categories_cached_byte_size_{0}, + entity_types_{}, + _entity_types_cached_byte_size_{0}, + vendor_code_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + device_brand_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + device_model_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + serial_number_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + port_{0u}, + device_type_{static_cast< ::control_service::DeviceType_Enum >(0)}, + heartbeat_timeout_seconds_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SetConfigRequest::SetConfigRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetConfigRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetConfigRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetConfigRequestDefaultTypeInternal() {} + union { + SetConfigRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetConfigRequestDefaultTypeInternal _SetConfigRequest_default_instance_; + +inline constexpr RegisterRemoteSkiRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : remote_ski_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RegisterRemoteSkiRequest::RegisterRemoteSkiRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RegisterRemoteSkiRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RegisterRemoteSkiRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RegisterRemoteSkiRequestDefaultTypeInternal() {} + union { + RegisterRemoteSkiRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisterRemoteSkiRequestDefaultTypeInternal _RegisterRemoteSkiRequest_default_instance_; + template +PROTOBUF_CONSTEXPR EmptyResponse::EmptyResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct EmptyResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR EmptyResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EmptyResponseDefaultTypeInternal() {} + union { + EmptyResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmptyResponseDefaultTypeInternal _EmptyResponse_default_instance_; + template +PROTOBUF_CONSTEXPR EmptyRequest::EmptyRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct EmptyRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR EmptyRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EmptyRequestDefaultTypeInternal() {} + union { + EmptyRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmptyRequestDefaultTypeInternal _EmptyRequest_default_instance_; + +inline constexpr AddUseCaseResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : endpoint_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR AddUseCaseResponse::AddUseCaseResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct AddUseCaseResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR AddUseCaseResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~AddUseCaseResponseDefaultTypeInternal() {} + union { + AddUseCaseResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddUseCaseResponseDefaultTypeInternal _AddUseCaseResponse_default_instance_; + +inline constexpr SubscribeUseCaseEventsRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + entity_address_{nullptr}, + use_case_{nullptr} {} + +template +PROTOBUF_CONSTEXPR SubscribeUseCaseEventsRequest::SubscribeUseCaseEventsRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SubscribeUseCaseEventsRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SubscribeUseCaseEventsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SubscribeUseCaseEventsRequestDefaultTypeInternal() {} + union { + SubscribeUseCaseEventsRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscribeUseCaseEventsRequestDefaultTypeInternal _SubscribeUseCaseEventsRequest_default_instance_; + +inline constexpr RemoveEntityRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + address_{nullptr} {} + +template +PROTOBUF_CONSTEXPR RemoveEntityRequest::RemoveEntityRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RemoveEntityRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RemoveEntityRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RemoveEntityRequestDefaultTypeInternal() {} + union { + RemoveEntityRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemoveEntityRequestDefaultTypeInternal _RemoveEntityRequest_default_instance_; + +inline constexpr AddUseCaseRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + entity_address_{nullptr}, + use_case_{nullptr} {} + +template +PROTOBUF_CONSTEXPR AddUseCaseRequest::AddUseCaseRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct AddUseCaseRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR AddUseCaseRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~AddUseCaseRequestDefaultTypeInternal() {} + union { + AddUseCaseRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddUseCaseRequestDefaultTypeInternal _AddUseCaseRequest_default_instance_; + +inline constexpr AddEntityRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + address_{nullptr}, + type_{static_cast< ::control_service::EntityType_Enum >(0)} {} + +template +PROTOBUF_CONSTEXPR AddEntityRequest::AddEntityRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct AddEntityRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR AddEntityRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~AddEntityRequestDefaultTypeInternal() {} + union { + AddEntityRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddEntityRequestDefaultTypeInternal _AddEntityRequest_default_instance_; + +inline constexpr SubscribeUseCaseEventsResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + remote_ski_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + remote_entity_address_{nullptr}, + use_case_event_{nullptr} {} + +template +PROTOBUF_CONSTEXPR SubscribeUseCaseEventsResponse::SubscribeUseCaseEventsResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SubscribeUseCaseEventsResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR SubscribeUseCaseEventsResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SubscribeUseCaseEventsResponseDefaultTypeInternal() {} + union { + SubscribeUseCaseEventsResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscribeUseCaseEventsResponseDefaultTypeInternal _SubscribeUseCaseEventsResponse_default_instance_; +} // namespace control_service +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_control_5fservice_2fmessages_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_control_5fservice_2fmessages_2eproto = nullptr; +const ::uint32_t + TableStruct_control_5fservice_2fmessages_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::control_service::EmptyRequest, _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(::control_service::EmptyResponse, _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(::control_service::SetConfigRequest, _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(::control_service::SetConfigRequest, _impl_.port_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.vendor_code_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.device_brand_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.device_model_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.serial_number_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.device_categories_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.device_type_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.entity_types_), + PROTOBUF_FIELD_OFFSET(::control_service::SetConfigRequest, _impl_.heartbeat_timeout_seconds_), + PROTOBUF_FIELD_OFFSET(::control_service::AddEntityRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::control_service::AddEntityRequest, _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(::control_service::AddEntityRequest, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::control_service::AddEntityRequest, _impl_.address_), + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::control_service::RemoveEntityRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::control_service::RemoveEntityRequest, _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(::control_service::RemoveEntityRequest, _impl_.address_), + 0, + PROTOBUF_FIELD_OFFSET(::control_service::AddUseCaseRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::control_service::AddUseCaseRequest, _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(::control_service::AddUseCaseRequest, _impl_.entity_address_), + PROTOBUF_FIELD_OFFSET(::control_service::AddUseCaseRequest, _impl_.use_case_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::control_service::AddUseCaseResponse, _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(::control_service::AddUseCaseResponse, _impl_.endpoint_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::control_service::RegisterRemoteSkiRequest, _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(::control_service::RegisterRemoteSkiRequest, _impl_.remote_ski_), + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsRequest, _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(::control_service::SubscribeUseCaseEventsRequest, _impl_.entity_address_), + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsRequest, _impl_.use_case_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsResponse, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsResponse, _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(::control_service::SubscribeUseCaseEventsResponse, _impl_.remote_ski_), + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsResponse, _impl_.remote_entity_address_), + PROTOBUF_FIELD_OFFSET(::control_service::SubscribeUseCaseEventsResponse, _impl_.use_case_event_), + ~0u, + 0, + 1, +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::control_service::EmptyRequest)}, + {8, -1, -1, sizeof(::control_service::EmptyResponse)}, + {16, -1, -1, sizeof(::control_service::SetConfigRequest)}, + {33, 43, -1, sizeof(::control_service::AddEntityRequest)}, + {45, 54, -1, sizeof(::control_service::RemoveEntityRequest)}, + {55, 65, -1, sizeof(::control_service::AddUseCaseRequest)}, + {67, -1, -1, sizeof(::control_service::AddUseCaseResponse)}, + {76, -1, -1, sizeof(::control_service::RegisterRemoteSkiRequest)}, + {85, 95, -1, sizeof(::control_service::SubscribeUseCaseEventsRequest)}, + {97, 108, -1, sizeof(::control_service::SubscribeUseCaseEventsResponse)}, +}; +static const ::_pb::Message* const file_default_instances[] = { + &::control_service::_EmptyRequest_default_instance_._instance, + &::control_service::_EmptyResponse_default_instance_._instance, + &::control_service::_SetConfigRequest_default_instance_._instance, + &::control_service::_AddEntityRequest_default_instance_._instance, + &::control_service::_RemoveEntityRequest_default_instance_._instance, + &::control_service::_AddUseCaseRequest_default_instance_._instance, + &::control_service::_AddUseCaseResponse_default_instance_._instance, + &::control_service::_RegisterRemoteSkiRequest_default_instance_._instance, + &::control_service::_SubscribeUseCaseEventsRequest_default_instance_._instance, + &::control_service::_SubscribeUseCaseEventsResponse_default_instance_._instance, +}; +const char descriptor_table_protodef_control_5fservice_2fmessages_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\036control_service/messages.proto\022\017contro" + "l_service\032\033control_service/types.proto\032\030" + "common_types/types.proto\"\016\n\014EmptyRequest" + "\"\017\n\rEmptyResponse\"\313\002\n\020SetConfigRequest\022\014" + "\n\004port\030\001 \001(\r\022\023\n\013vendor_code\030\002 \001(\t\022\024\n\014dev" + "ice_brand\030\003 \001(\t\022\024\n\014device_model\030\004 \001(\t\022\025\n" + "\rserial_number\030\005 \001(\t\022\?\n\021device_categorie" + "s\030\006 \003(\0162$.control_service.DeviceCategory" + ".Enum\0225\n\013device_type\030\007 \001(\0162 .control_ser" + "vice.DeviceType.Enum\0226\n\014entity_types\030\010 \003" + "(\0162 .control_service.EntityType.Enum\022!\n\031" + "heartbeat_timeout_seconds\030\t \001(\r\"p\n\020AddEn" + "tityRequest\022.\n\004type\030\001 \001(\0162 .control_serv" + "ice.EntityType.Enum\022,\n\007address\030\002 \001(\0132\033.c" + "ommon_types.EntityAddress\"C\n\023RemoveEntit" + "yRequest\022,\n\007address\030\001 \001(\0132\033.common_types" + ".EntityAddress\"t\n\021AddUseCaseRequest\0223\n\016e" + "ntity_address\030\001 \001(\0132\033.common_types.Entit" + "yAddress\022*\n\010use_case\030\002 \001(\0132\030.control_ser" + "vice.UseCase\"&\n\022AddUseCaseResponse\022\020\n\010en" + "dpoint\030\001 \001(\t\".\n\030RegisterRemoteSkiRequest" + "\022\022\n\nremote_ski\030\001 \001(\t\"\200\001\n\035SubscribeUseCas" + "eEventsRequest\0223\n\016entity_address\030\001 \001(\0132\033" + ".common_types.EntityAddress\022*\n\010use_case\030" + "\002 \001(\0132\030.control_service.UseCase\"\247\001\n\036Subs" + "cribeUseCaseEventsResponse\022\022\n\nremote_ski" + "\030\001 \001(\t\022:\n\025remote_entity_address\030\002 \001(\0132\033." + "common_types.EntityAddress\0225\n\016use_case_e" + "vent\030\003 \001(\0132\035.control_service.UseCaseEven" + "tB=Z;github.com/enbility/eebus-grpc/rpc_" + "services/control_serviceb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_control_5fservice_2fmessages_2eproto_deps[2] = + { + &::descriptor_table_common_5ftypes_2ftypes_2eproto, + &::descriptor_table_control_5fservice_2ftypes_2eproto, +}; +static ::absl::once_flag descriptor_table_control_5fservice_2fmessages_2eproto_once; +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_control_5fservice_2fmessages_2eproto = { + false, + false, + 1232, + descriptor_table_protodef_control_5fservice_2fmessages_2eproto, + "control_service/messages.proto", + &descriptor_table_control_5fservice_2fmessages_2eproto_once, + descriptor_table_control_5fservice_2fmessages_2eproto_deps, + 2, + 10, + schemas, + file_default_instances, + TableStruct_control_5fservice_2fmessages_2eproto::offsets, + file_level_enum_descriptors_control_5fservice_2fmessages_2eproto, + file_level_service_descriptors_control_5fservice_2fmessages_2eproto, +}; +namespace control_service { +// =================================================================== + +class EmptyRequest::_Internal { + public: +}; + +EmptyRequest::EmptyRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.EmptyRequest) +} +EmptyRequest::EmptyRequest( + ::google::protobuf::Arena* arena, + const EmptyRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + EmptyRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.EmptyRequest) +} + +inline void* EmptyRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) EmptyRequest(arena); +} +constexpr auto EmptyRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(EmptyRequest), + alignof(EmptyRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull EmptyRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_EmptyRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &EmptyRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &EmptyRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &EmptyRequest::ByteSizeLong, + &EmptyRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(EmptyRequest, _impl_._cached_size_), + false, + }, + &EmptyRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* EmptyRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> EmptyRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::EmptyRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata EmptyRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class EmptyResponse::_Internal { + public: +}; + +EmptyResponse::EmptyResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.EmptyResponse) +} +EmptyResponse::EmptyResponse( + ::google::protobuf::Arena* arena, + const EmptyResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + EmptyResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.EmptyResponse) +} + +inline void* EmptyResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) EmptyResponse(arena); +} +constexpr auto EmptyResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(EmptyResponse), + alignof(EmptyResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull EmptyResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_EmptyResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &EmptyResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &EmptyResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &EmptyResponse::ByteSizeLong, + &EmptyResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(EmptyResponse, _impl_._cached_size_), + false, + }, + &EmptyResponse::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* EmptyResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> EmptyResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::EmptyResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata EmptyResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetConfigRequest::_Internal { + public: +}; + +SetConfigRequest::SetConfigRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.SetConfigRequest) +} +inline PROTOBUF_NDEBUG_INLINE SetConfigRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::SetConfigRequest& from_msg) + : device_categories_{visibility, arena, from.device_categories_}, + _device_categories_cached_byte_size_{0}, + entity_types_{visibility, arena, from.entity_types_}, + _entity_types_cached_byte_size_{0}, + vendor_code_(arena, from.vendor_code_), + device_brand_(arena, from.device_brand_), + device_model_(arena, from.device_model_), + serial_number_(arena, from.serial_number_), + _cached_size_{0} {} + +SetConfigRequest::SetConfigRequest( + ::google::protobuf::Arena* arena, + const SetConfigRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetConfigRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, port_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, port_), + offsetof(Impl_, heartbeat_timeout_seconds_) - + offsetof(Impl_, port_) + + sizeof(Impl_::heartbeat_timeout_seconds_)); + + // @@protoc_insertion_point(copy_constructor:control_service.SetConfigRequest) +} +inline PROTOBUF_NDEBUG_INLINE SetConfigRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : device_categories_{visibility, arena}, + _device_categories_cached_byte_size_{0}, + entity_types_{visibility, arena}, + _entity_types_cached_byte_size_{0}, + vendor_code_(arena), + device_brand_(arena), + device_model_(arena), + serial_number_(arena), + _cached_size_{0} {} + +inline void SetConfigRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, port_), + 0, + offsetof(Impl_, heartbeat_timeout_seconds_) - + offsetof(Impl_, port_) + + sizeof(Impl_::heartbeat_timeout_seconds_)); +} +SetConfigRequest::~SetConfigRequest() { + // @@protoc_insertion_point(destructor:control_service.SetConfigRequest) + SharedDtor(*this); +} +inline void SetConfigRequest::SharedDtor(MessageLite& self) { + SetConfigRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.vendor_code_.Destroy(); + this_._impl_.device_brand_.Destroy(); + this_._impl_.device_model_.Destroy(); + this_._impl_.serial_number_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* SetConfigRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetConfigRequest(arena); +} +constexpr auto SetConfigRequest::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_categories_) + + decltype(SetConfigRequest::_impl_.device_categories_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.entity_types_) + + decltype(SetConfigRequest::_impl_.entity_types_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(SetConfigRequest), alignof(SetConfigRequest), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&SetConfigRequest::PlacementNew_, + sizeof(SetConfigRequest), + alignof(SetConfigRequest)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetConfigRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetConfigRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetConfigRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetConfigRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetConfigRequest::ByteSizeLong, + &SetConfigRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_._cached_size_), + false, + }, + &SetConfigRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetConfigRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 9, 0, 97, 2> SetConfigRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 9, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966784, // skipmap + offsetof(decltype(_table_), field_entries), + 9, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::SetConfigRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 port = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetConfigRequest, _impl_.port_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.port_)}}, + // string vendor_code = 2; + {::_pbi::TcParser::FastUS1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.vendor_code_)}}, + // string device_brand = 3; + {::_pbi::TcParser::FastUS1, + {26, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_brand_)}}, + // string device_model = 4; + {::_pbi::TcParser::FastUS1, + {34, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_model_)}}, + // string serial_number = 5; + {::_pbi::TcParser::FastUS1, + {42, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.serial_number_)}}, + // repeated .control_service.DeviceCategory.Enum device_categories = 6; + {::_pbi::TcParser::FastV32P1, + {50, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_categories_)}}, + // .control_service.DeviceType.Enum device_type = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetConfigRequest, _impl_.device_type_), 63>(), + {56, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_type_)}}, + // repeated .control_service.EntityType.Enum entity_types = 8; + {::_pbi::TcParser::FastV32P1, + {66, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.entity_types_)}}, + // uint32 heartbeat_timeout_seconds = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetConfigRequest, _impl_.heartbeat_timeout_seconds_), 63>(), + {72, 63, 0, PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.heartbeat_timeout_seconds_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 1; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.port_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // string vendor_code = 2; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.vendor_code_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string device_brand = 3; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_brand_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string device_model = 4; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_model_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string serial_number = 5; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.serial_number_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // repeated .control_service.DeviceCategory.Enum device_categories = 6; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_categories_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedOpenEnum)}, + // .control_service.DeviceType.Enum device_type = 7; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.device_type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, + // repeated .control_service.EntityType.Enum entity_types = 8; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.entity_types_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedOpenEnum)}, + // uint32 heartbeat_timeout_seconds = 9; + {PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.heartbeat_timeout_seconds_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + "\40\0\13\14\14\15\0\0\0\0\0\0\0\0\0\0" + "control_service.SetConfigRequest" + "vendor_code" + "device_brand" + "device_model" + "serial_number" + }}, +}; + +PROTOBUF_NOINLINE void SetConfigRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.SetConfigRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.device_categories_.Clear(); + _impl_.entity_types_.Clear(); + _impl_.vendor_code_.ClearToEmpty(); + _impl_.device_brand_.ClearToEmpty(); + _impl_.device_model_.ClearToEmpty(); + _impl_.serial_number_.ClearToEmpty(); + ::memset(&_impl_.port_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.heartbeat_timeout_seconds_) - + reinterpret_cast(&_impl_.port_)) + sizeof(_impl_.heartbeat_timeout_seconds_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetConfigRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetConfigRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetConfigRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetConfigRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.SetConfigRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 port = 1; + if (this_._internal_port() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_port(), target); + } + + // string vendor_code = 2; + if (!this_._internal_vendor_code().empty()) { + const std::string& _s = this_._internal_vendor_code(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.SetConfigRequest.vendor_code"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // string device_brand = 3; + if (!this_._internal_device_brand().empty()) { + const std::string& _s = this_._internal_device_brand(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.SetConfigRequest.device_brand"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + // string device_model = 4; + if (!this_._internal_device_model().empty()) { + const std::string& _s = this_._internal_device_model(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.SetConfigRequest.device_model"); + target = stream->WriteStringMaybeAliased(4, _s, target); + } + + // string serial_number = 5; + if (!this_._internal_serial_number().empty()) { + const std::string& _s = this_._internal_serial_number(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.SetConfigRequest.serial_number"); + target = stream->WriteStringMaybeAliased(5, _s, target); + } + + // repeated .control_service.DeviceCategory.Enum device_categories = 6; + { + std::size_t byte_size = + this_._impl_._device_categories_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteEnumPacked( + 6, this_._internal_device_categories(), byte_size, target); + } + } + + // .control_service.DeviceType.Enum device_type = 7; + if (this_._internal_device_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 7, this_._internal_device_type(), target); + } + + // repeated .control_service.EntityType.Enum entity_types = 8; + { + std::size_t byte_size = + this_._impl_._entity_types_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteEnumPacked( + 8, this_._internal_entity_types(), byte_size, target); + } + } + + // uint32 heartbeat_timeout_seconds = 9; + if (this_._internal_heartbeat_timeout_seconds() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this_._internal_heartbeat_timeout_seconds(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.SetConfigRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetConfigRequest::ByteSizeLong(const MessageLite& base) { + const SetConfigRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetConfigRequest::ByteSizeLong() const { + const SetConfigRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.SetConfigRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .control_service.DeviceCategory.Enum device_categories = 6; + { + total_size += ::_pbi::WireFormatLite::EnumSizeWithPackedTagSize( + this_._internal_device_categories(), 1, this_._impl_._device_categories_cached_byte_size_); + } + // repeated .control_service.EntityType.Enum entity_types = 8; + { + total_size += ::_pbi::WireFormatLite::EnumSizeWithPackedTagSize( + this_._internal_entity_types(), 1, this_._impl_._entity_types_cached_byte_size_); + } + } + { + // string vendor_code = 2; + if (!this_._internal_vendor_code().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_vendor_code()); + } + // string device_brand = 3; + if (!this_._internal_device_brand().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_device_brand()); + } + // string device_model = 4; + if (!this_._internal_device_model().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_device_model()); + } + // string serial_number = 5; + if (!this_._internal_serial_number().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_serial_number()); + } + // uint32 port = 1; + if (this_._internal_port() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_port()); + } + // .control_service.DeviceType.Enum device_type = 7; + if (this_._internal_device_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_device_type()); + } + // uint32 heartbeat_timeout_seconds = 9; + if (this_._internal_heartbeat_timeout_seconds() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_heartbeat_timeout_seconds()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SetConfigRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.SetConfigRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_device_categories()->MergeFrom(from._internal_device_categories()); + _this->_internal_mutable_entity_types()->MergeFrom(from._internal_entity_types()); + if (!from._internal_vendor_code().empty()) { + _this->_internal_set_vendor_code(from._internal_vendor_code()); + } + if (!from._internal_device_brand().empty()) { + _this->_internal_set_device_brand(from._internal_device_brand()); + } + if (!from._internal_device_model().empty()) { + _this->_internal_set_device_model(from._internal_device_model()); + } + if (!from._internal_serial_number().empty()) { + _this->_internal_set_serial_number(from._internal_serial_number()); + } + if (from._internal_port() != 0) { + _this->_impl_.port_ = from._impl_.port_; + } + if (from._internal_device_type() != 0) { + _this->_impl_.device_type_ = from._impl_.device_type_; + } + if (from._internal_heartbeat_timeout_seconds() != 0) { + _this->_impl_.heartbeat_timeout_seconds_ = from._impl_.heartbeat_timeout_seconds_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SetConfigRequest::CopyFrom(const SetConfigRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.SetConfigRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetConfigRequest::InternalSwap(SetConfigRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.device_categories_.InternalSwap(&other->_impl_.device_categories_); + _impl_.entity_types_.InternalSwap(&other->_impl_.entity_types_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.vendor_code_, &other->_impl_.vendor_code_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.device_brand_, &other->_impl_.device_brand_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.device_model_, &other->_impl_.device_model_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.serial_number_, &other->_impl_.serial_number_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.heartbeat_timeout_seconds_) + + sizeof(SetConfigRequest::_impl_.heartbeat_timeout_seconds_) + - PROTOBUF_FIELD_OFFSET(SetConfigRequest, _impl_.port_)>( + reinterpret_cast(&_impl_.port_), + reinterpret_cast(&other->_impl_.port_)); +} + +::google::protobuf::Metadata SetConfigRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class AddEntityRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_._has_bits_); +}; + +void AddEntityRequest::clear_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.address_ != nullptr) _impl_.address_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +AddEntityRequest::AddEntityRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.AddEntityRequest) +} +inline PROTOBUF_NDEBUG_INLINE AddEntityRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::AddEntityRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +AddEntityRequest::AddEntityRequest( + ::google::protobuf::Arena* arena, + const AddEntityRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + AddEntityRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>( + arena, *from._impl_.address_) + : nullptr; + _impl_.type_ = from._impl_.type_; + + // @@protoc_insertion_point(copy_constructor:control_service.AddEntityRequest) +} +inline PROTOBUF_NDEBUG_INLINE AddEntityRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void AddEntityRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, address_), + 0, + offsetof(Impl_, type_) - + offsetof(Impl_, address_) + + sizeof(Impl_::type_)); +} +AddEntityRequest::~AddEntityRequest() { + // @@protoc_insertion_point(destructor:control_service.AddEntityRequest) + SharedDtor(*this); +} +inline void AddEntityRequest::SharedDtor(MessageLite& self) { + AddEntityRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.address_; + this_._impl_.~Impl_(); +} + +inline void* AddEntityRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) AddEntityRequest(arena); +} +constexpr auto AddEntityRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AddEntityRequest), + alignof(AddEntityRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull AddEntityRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_AddEntityRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &AddEntityRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &AddEntityRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &AddEntityRequest::ByteSizeLong, + &AddEntityRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_._cached_size_), + false, + }, + &AddEntityRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* AddEntityRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> AddEntityRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(AddEntityRequest, _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), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::AddEntityRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .common_types.EntityAddress address = 2; + {::_pbi::TcParser::FastMtS1, + {18, 0, 0, PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_.address_)}}, + // .control_service.EntityType.Enum type = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AddEntityRequest, _impl_.type_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_.type_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .control_service.EntityType.Enum type = 1; + {PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_.type_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, + // .common_types.EntityAddress address = 2; + {PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::EntityAddress>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void AddEntityRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.AddEntityRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.address_ != nullptr); + _impl_.address_->Clear(); + } + _impl_.type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* AddEntityRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const AddEntityRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* AddEntityRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const AddEntityRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.AddEntityRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // .control_service.EntityType.Enum type = 1; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this_._internal_type(), target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.EntityAddress address = 2; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.address_, this_._impl_.address_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.AddEntityRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t AddEntityRequest::ByteSizeLong(const MessageLite& base) { + const AddEntityRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t AddEntityRequest::ByteSizeLong() const { + const AddEntityRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.AddEntityRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // .common_types.EntityAddress address = 2; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.address_); + } + } + { + // .control_service.EntityType.Enum type = 1; + if (this_._internal_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_type()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void AddEntityRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.AddEntityRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.address_ != nullptr); + if (_this->_impl_.address_ == nullptr) { + _this->_impl_.address_ = + ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>(arena, *from._impl_.address_); + } else { + _this->_impl_.address_->MergeFrom(*from._impl_.address_); + } + } + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void AddEntityRequest::CopyFrom(const AddEntityRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.AddEntityRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void AddEntityRequest::InternalSwap(AddEntityRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_.type_) + + sizeof(AddEntityRequest::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(AddEntityRequest, _impl_.address_)>( + reinterpret_cast(&_impl_.address_), + reinterpret_cast(&other->_impl_.address_)); +} + +::google::protobuf::Metadata AddEntityRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RemoveEntityRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RemoveEntityRequest, _impl_._has_bits_); +}; + +void RemoveEntityRequest::clear_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.address_ != nullptr) _impl_.address_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +RemoveEntityRequest::RemoveEntityRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.RemoveEntityRequest) +} +inline PROTOBUF_NDEBUG_INLINE RemoveEntityRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::RemoveEntityRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +RemoveEntityRequest::RemoveEntityRequest( + ::google::protobuf::Arena* arena, + const RemoveEntityRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RemoveEntityRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>( + arena, *from._impl_.address_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:control_service.RemoveEntityRequest) +} +inline PROTOBUF_NDEBUG_INLINE RemoveEntityRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RemoveEntityRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.address_ = {}; +} +RemoveEntityRequest::~RemoveEntityRequest() { + // @@protoc_insertion_point(destructor:control_service.RemoveEntityRequest) + SharedDtor(*this); +} +inline void RemoveEntityRequest::SharedDtor(MessageLite& self) { + RemoveEntityRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.address_; + this_._impl_.~Impl_(); +} + +inline void* RemoveEntityRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RemoveEntityRequest(arena); +} +constexpr auto RemoveEntityRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RemoveEntityRequest), + alignof(RemoveEntityRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RemoveEntityRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RemoveEntityRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RemoveEntityRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RemoveEntityRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RemoveEntityRequest::ByteSizeLong, + &RemoveEntityRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RemoveEntityRequest, _impl_._cached_size_), + false, + }, + &RemoveEntityRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RemoveEntityRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> RemoveEntityRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RemoveEntityRequest, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::RemoveEntityRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .common_types.EntityAddress address = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(RemoveEntityRequest, _impl_.address_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .common_types.EntityAddress address = 1; + {PROTOBUF_FIELD_OFFSET(RemoveEntityRequest, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::EntityAddress>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void RemoveEntityRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.RemoveEntityRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.address_ != nullptr); + _impl_.address_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RemoveEntityRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RemoveEntityRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RemoveEntityRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RemoveEntityRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.RemoveEntityRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.EntityAddress address = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.address_, this_._impl_.address_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.RemoveEntityRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RemoveEntityRequest::ByteSizeLong(const MessageLite& base) { + const RemoveEntityRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RemoveEntityRequest::ByteSizeLong() const { + const RemoveEntityRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.RemoveEntityRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // .common_types.EntityAddress address = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.address_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RemoveEntityRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.RemoveEntityRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.address_ != nullptr); + if (_this->_impl_.address_ == nullptr) { + _this->_impl_.address_ = + ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>(arena, *from._impl_.address_); + } else { + _this->_impl_.address_->MergeFrom(*from._impl_.address_); + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RemoveEntityRequest::CopyFrom(const RemoveEntityRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.RemoveEntityRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RemoveEntityRequest::InternalSwap(RemoveEntityRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.address_, other->_impl_.address_); +} + +::google::protobuf::Metadata RemoveEntityRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class AddUseCaseRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_._has_bits_); +}; + +void AddUseCaseRequest::clear_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.entity_address_ != nullptr) _impl_.entity_address_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +void AddUseCaseRequest::clear_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_ != nullptr) _impl_.use_case_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +AddUseCaseRequest::AddUseCaseRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.AddUseCaseRequest) +} +inline PROTOBUF_NDEBUG_INLINE AddUseCaseRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::AddUseCaseRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +AddUseCaseRequest::AddUseCaseRequest( + ::google::protobuf::Arena* arena, + const AddUseCaseRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + AddUseCaseRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.entity_address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>( + arena, *from._impl_.entity_address_) + : nullptr; + _impl_.use_case_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::control_service::UseCase>( + arena, *from._impl_.use_case_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:control_service.AddUseCaseRequest) +} +inline PROTOBUF_NDEBUG_INLINE AddUseCaseRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void AddUseCaseRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, entity_address_), + 0, + offsetof(Impl_, use_case_) - + offsetof(Impl_, entity_address_) + + sizeof(Impl_::use_case_)); +} +AddUseCaseRequest::~AddUseCaseRequest() { + // @@protoc_insertion_point(destructor:control_service.AddUseCaseRequest) + SharedDtor(*this); +} +inline void AddUseCaseRequest::SharedDtor(MessageLite& self) { + AddUseCaseRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.entity_address_; + delete this_._impl_.use_case_; + this_._impl_.~Impl_(); +} + +inline void* AddUseCaseRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) AddUseCaseRequest(arena); +} +constexpr auto AddUseCaseRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AddUseCaseRequest), + alignof(AddUseCaseRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull AddUseCaseRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_AddUseCaseRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &AddUseCaseRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &AddUseCaseRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &AddUseCaseRequest::ByteSizeLong, + &AddUseCaseRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_._cached_size_), + false, + }, + &AddUseCaseRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* AddUseCaseRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> AddUseCaseRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _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), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::AddUseCaseRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .control_service.UseCase use_case = 2; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_.use_case_)}}, + // .common_types.EntityAddress entity_address = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_.entity_address_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .common_types.EntityAddress entity_address = 1; + {PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_.entity_address_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .control_service.UseCase use_case = 2; + {PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_.use_case_), _Internal::kHasBitsOffset + 1, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::EntityAddress>()}, + {::_pbi::TcParser::GetTable<::control_service::UseCase>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void AddUseCaseRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.AddUseCaseRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.entity_address_ != nullptr); + _impl_.entity_address_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.use_case_ != nullptr); + _impl_.use_case_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* AddUseCaseRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const AddUseCaseRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* AddUseCaseRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const AddUseCaseRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.AddUseCaseRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.EntityAddress entity_address = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.entity_address_, this_._impl_.entity_address_->GetCachedSize(), target, + stream); + } + + // .control_service.UseCase use_case = 2; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.use_case_, this_._impl_.use_case_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.AddUseCaseRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t AddUseCaseRequest::ByteSizeLong(const MessageLite& base) { + const AddUseCaseRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t AddUseCaseRequest::ByteSizeLong() const { + const AddUseCaseRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.AddUseCaseRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .common_types.EntityAddress entity_address = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.entity_address_); + } + // .control_service.UseCase use_case = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.use_case_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void AddUseCaseRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.AddUseCaseRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.entity_address_ != nullptr); + if (_this->_impl_.entity_address_ == nullptr) { + _this->_impl_.entity_address_ = + ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>(arena, *from._impl_.entity_address_); + } else { + _this->_impl_.entity_address_->MergeFrom(*from._impl_.entity_address_); + } + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(from._impl_.use_case_ != nullptr); + if (_this->_impl_.use_case_ == nullptr) { + _this->_impl_.use_case_ = + ::google::protobuf::Message::CopyConstruct<::control_service::UseCase>(arena, *from._impl_.use_case_); + } else { + _this->_impl_.use_case_->MergeFrom(*from._impl_.use_case_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void AddUseCaseRequest::CopyFrom(const AddUseCaseRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.AddUseCaseRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void AddUseCaseRequest::InternalSwap(AddUseCaseRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_.use_case_) + + sizeof(AddUseCaseRequest::_impl_.use_case_) + - PROTOBUF_FIELD_OFFSET(AddUseCaseRequest, _impl_.entity_address_)>( + reinterpret_cast(&_impl_.entity_address_), + reinterpret_cast(&other->_impl_.entity_address_)); +} + +::google::protobuf::Metadata AddUseCaseRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class AddUseCaseResponse::_Internal { + public: +}; + +AddUseCaseResponse::AddUseCaseResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.AddUseCaseResponse) +} +inline PROTOBUF_NDEBUG_INLINE AddUseCaseResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::AddUseCaseResponse& from_msg) + : endpoint_(arena, from.endpoint_), + _cached_size_{0} {} + +AddUseCaseResponse::AddUseCaseResponse( + ::google::protobuf::Arena* arena, + const AddUseCaseResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + AddUseCaseResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:control_service.AddUseCaseResponse) +} +inline PROTOBUF_NDEBUG_INLINE AddUseCaseResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : endpoint_(arena), + _cached_size_{0} {} + +inline void AddUseCaseResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +AddUseCaseResponse::~AddUseCaseResponse() { + // @@protoc_insertion_point(destructor:control_service.AddUseCaseResponse) + SharedDtor(*this); +} +inline void AddUseCaseResponse::SharedDtor(MessageLite& self) { + AddUseCaseResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.endpoint_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* AddUseCaseResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) AddUseCaseResponse(arena); +} +constexpr auto AddUseCaseResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(AddUseCaseResponse), + alignof(AddUseCaseResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull AddUseCaseResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_AddUseCaseResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &AddUseCaseResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &AddUseCaseResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &AddUseCaseResponse::ByteSizeLong, + &AddUseCaseResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(AddUseCaseResponse, _impl_._cached_size_), + false, + }, + &AddUseCaseResponse::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* AddUseCaseResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 51, 2> AddUseCaseResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::AddUseCaseResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string endpoint = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(AddUseCaseResponse, _impl_.endpoint_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string endpoint = 1; + {PROTOBUF_FIELD_OFFSET(AddUseCaseResponse, _impl_.endpoint_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\42\10\0\0\0\0\0\0" + "control_service.AddUseCaseResponse" + "endpoint" + }}, +}; + +PROTOBUF_NOINLINE void AddUseCaseResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.AddUseCaseResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.endpoint_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* AddUseCaseResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const AddUseCaseResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* AddUseCaseResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const AddUseCaseResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.AddUseCaseResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string endpoint = 1; + if (!this_._internal_endpoint().empty()) { + const std::string& _s = this_._internal_endpoint(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.AddUseCaseResponse.endpoint"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.AddUseCaseResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t AddUseCaseResponse::ByteSizeLong(const MessageLite& base) { + const AddUseCaseResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t AddUseCaseResponse::ByteSizeLong() const { + const AddUseCaseResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.AddUseCaseResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string endpoint = 1; + if (!this_._internal_endpoint().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_endpoint()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void AddUseCaseResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.AddUseCaseResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_endpoint().empty()) { + _this->_internal_set_endpoint(from._internal_endpoint()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void AddUseCaseResponse::CopyFrom(const AddUseCaseResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.AddUseCaseResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void AddUseCaseResponse::InternalSwap(AddUseCaseResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.endpoint_, &other->_impl_.endpoint_, arena); +} + +::google::protobuf::Metadata AddUseCaseResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RegisterRemoteSkiRequest::_Internal { + public: +}; + +RegisterRemoteSkiRequest::RegisterRemoteSkiRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.RegisterRemoteSkiRequest) +} +inline PROTOBUF_NDEBUG_INLINE RegisterRemoteSkiRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::RegisterRemoteSkiRequest& from_msg) + : remote_ski_(arena, from.remote_ski_), + _cached_size_{0} {} + +RegisterRemoteSkiRequest::RegisterRemoteSkiRequest( + ::google::protobuf::Arena* arena, + const RegisterRemoteSkiRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RegisterRemoteSkiRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:control_service.RegisterRemoteSkiRequest) +} +inline PROTOBUF_NDEBUG_INLINE RegisterRemoteSkiRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : remote_ski_(arena), + _cached_size_{0} {} + +inline void RegisterRemoteSkiRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +RegisterRemoteSkiRequest::~RegisterRemoteSkiRequest() { + // @@protoc_insertion_point(destructor:control_service.RegisterRemoteSkiRequest) + SharedDtor(*this); +} +inline void RegisterRemoteSkiRequest::SharedDtor(MessageLite& self) { + RegisterRemoteSkiRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.remote_ski_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* RegisterRemoteSkiRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RegisterRemoteSkiRequest(arena); +} +constexpr auto RegisterRemoteSkiRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RegisterRemoteSkiRequest), + alignof(RegisterRemoteSkiRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull RegisterRemoteSkiRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_RegisterRemoteSkiRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RegisterRemoteSkiRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RegisterRemoteSkiRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RegisterRemoteSkiRequest::ByteSizeLong, + &RegisterRemoteSkiRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RegisterRemoteSkiRequest, _impl_._cached_size_), + false, + }, + &RegisterRemoteSkiRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* RegisterRemoteSkiRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 59, 2> RegisterRemoteSkiRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::RegisterRemoteSkiRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string remote_ski = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(RegisterRemoteSkiRequest, _impl_.remote_ski_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string remote_ski = 1; + {PROTOBUF_FIELD_OFFSET(RegisterRemoteSkiRequest, _impl_.remote_ski_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\50\12\0\0\0\0\0\0" + "control_service.RegisterRemoteSkiRequest" + "remote_ski" + }}, +}; + +PROTOBUF_NOINLINE void RegisterRemoteSkiRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.RegisterRemoteSkiRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.remote_ski_.ClearToEmpty(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RegisterRemoteSkiRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RegisterRemoteSkiRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RegisterRemoteSkiRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RegisterRemoteSkiRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.RegisterRemoteSkiRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string remote_ski = 1; + if (!this_._internal_remote_ski().empty()) { + const std::string& _s = this_._internal_remote_ski(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.RegisterRemoteSkiRequest.remote_ski"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.RegisterRemoteSkiRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RegisterRemoteSkiRequest::ByteSizeLong(const MessageLite& base) { + const RegisterRemoteSkiRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RegisterRemoteSkiRequest::ByteSizeLong() const { + const RegisterRemoteSkiRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.RegisterRemoteSkiRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string remote_ski = 1; + if (!this_._internal_remote_ski().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_remote_ski()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void RegisterRemoteSkiRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.RegisterRemoteSkiRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_remote_ski().empty()) { + _this->_internal_set_remote_ski(from._internal_remote_ski()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void RegisterRemoteSkiRequest::CopyFrom(const RegisterRemoteSkiRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.RegisterRemoteSkiRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RegisterRemoteSkiRequest::InternalSwap(RegisterRemoteSkiRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.remote_ski_, &other->_impl_.remote_ski_, arena); +} + +::google::protobuf::Metadata RegisterRemoteSkiRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SubscribeUseCaseEventsRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_._has_bits_); +}; + +void SubscribeUseCaseEventsRequest::clear_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.entity_address_ != nullptr) _impl_.entity_address_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +void SubscribeUseCaseEventsRequest::clear_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_ != nullptr) _impl_.use_case_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +SubscribeUseCaseEventsRequest::SubscribeUseCaseEventsRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.SubscribeUseCaseEventsRequest) +} +inline PROTOBUF_NDEBUG_INLINE SubscribeUseCaseEventsRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::SubscribeUseCaseEventsRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +SubscribeUseCaseEventsRequest::SubscribeUseCaseEventsRequest( + ::google::protobuf::Arena* arena, + const SubscribeUseCaseEventsRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SubscribeUseCaseEventsRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.entity_address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>( + arena, *from._impl_.entity_address_) + : nullptr; + _impl_.use_case_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::control_service::UseCase>( + arena, *from._impl_.use_case_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:control_service.SubscribeUseCaseEventsRequest) +} +inline PROTOBUF_NDEBUG_INLINE SubscribeUseCaseEventsRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SubscribeUseCaseEventsRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, entity_address_), + 0, + offsetof(Impl_, use_case_) - + offsetof(Impl_, entity_address_) + + sizeof(Impl_::use_case_)); +} +SubscribeUseCaseEventsRequest::~SubscribeUseCaseEventsRequest() { + // @@protoc_insertion_point(destructor:control_service.SubscribeUseCaseEventsRequest) + SharedDtor(*this); +} +inline void SubscribeUseCaseEventsRequest::SharedDtor(MessageLite& self) { + SubscribeUseCaseEventsRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.entity_address_; + delete this_._impl_.use_case_; + this_._impl_.~Impl_(); +} + +inline void* SubscribeUseCaseEventsRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SubscribeUseCaseEventsRequest(arena); +} +constexpr auto SubscribeUseCaseEventsRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SubscribeUseCaseEventsRequest), + alignof(SubscribeUseCaseEventsRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SubscribeUseCaseEventsRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SubscribeUseCaseEventsRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SubscribeUseCaseEventsRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SubscribeUseCaseEventsRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SubscribeUseCaseEventsRequest::ByteSizeLong, + &SubscribeUseCaseEventsRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_._cached_size_), + false, + }, + &SubscribeUseCaseEventsRequest::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SubscribeUseCaseEventsRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> SubscribeUseCaseEventsRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _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), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::SubscribeUseCaseEventsRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .control_service.UseCase use_case = 2; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_.use_case_)}}, + // .common_types.EntityAddress entity_address = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_.entity_address_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .common_types.EntityAddress entity_address = 1; + {PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_.entity_address_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .control_service.UseCase use_case = 2; + {PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_.use_case_), _Internal::kHasBitsOffset + 1, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::EntityAddress>()}, + {::_pbi::TcParser::GetTable<::control_service::UseCase>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void SubscribeUseCaseEventsRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.SubscribeUseCaseEventsRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.entity_address_ != nullptr); + _impl_.entity_address_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.use_case_ != nullptr); + _impl_.use_case_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SubscribeUseCaseEventsRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SubscribeUseCaseEventsRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SubscribeUseCaseEventsRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SubscribeUseCaseEventsRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.SubscribeUseCaseEventsRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.EntityAddress entity_address = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.entity_address_, this_._impl_.entity_address_->GetCachedSize(), target, + stream); + } + + // .control_service.UseCase use_case = 2; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.use_case_, this_._impl_.use_case_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.SubscribeUseCaseEventsRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SubscribeUseCaseEventsRequest::ByteSizeLong(const MessageLite& base) { + const SubscribeUseCaseEventsRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SubscribeUseCaseEventsRequest::ByteSizeLong() const { + const SubscribeUseCaseEventsRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.SubscribeUseCaseEventsRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .common_types.EntityAddress entity_address = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.entity_address_); + } + // .control_service.UseCase use_case = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.use_case_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SubscribeUseCaseEventsRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.SubscribeUseCaseEventsRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.entity_address_ != nullptr); + if (_this->_impl_.entity_address_ == nullptr) { + _this->_impl_.entity_address_ = + ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>(arena, *from._impl_.entity_address_); + } else { + _this->_impl_.entity_address_->MergeFrom(*from._impl_.entity_address_); + } + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(from._impl_.use_case_ != nullptr); + if (_this->_impl_.use_case_ == nullptr) { + _this->_impl_.use_case_ = + ::google::protobuf::Message::CopyConstruct<::control_service::UseCase>(arena, *from._impl_.use_case_); + } else { + _this->_impl_.use_case_->MergeFrom(*from._impl_.use_case_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SubscribeUseCaseEventsRequest::CopyFrom(const SubscribeUseCaseEventsRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.SubscribeUseCaseEventsRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SubscribeUseCaseEventsRequest::InternalSwap(SubscribeUseCaseEventsRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_.use_case_) + + sizeof(SubscribeUseCaseEventsRequest::_impl_.use_case_) + - PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsRequest, _impl_.entity_address_)>( + reinterpret_cast(&_impl_.entity_address_), + reinterpret_cast(&other->_impl_.entity_address_)); +} + +::google::protobuf::Metadata SubscribeUseCaseEventsRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SubscribeUseCaseEventsResponse::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_._has_bits_); +}; + +void SubscribeUseCaseEventsResponse::clear_remote_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.remote_entity_address_ != nullptr) _impl_.remote_entity_address_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +void SubscribeUseCaseEventsResponse::clear_use_case_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_event_ != nullptr) _impl_.use_case_event_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +SubscribeUseCaseEventsResponse::SubscribeUseCaseEventsResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.SubscribeUseCaseEventsResponse) +} +inline PROTOBUF_NDEBUG_INLINE SubscribeUseCaseEventsResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::SubscribeUseCaseEventsResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + remote_ski_(arena, from.remote_ski_) {} + +SubscribeUseCaseEventsResponse::SubscribeUseCaseEventsResponse( + ::google::protobuf::Arena* arena, + const SubscribeUseCaseEventsResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SubscribeUseCaseEventsResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.remote_entity_address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>( + arena, *from._impl_.remote_entity_address_) + : nullptr; + _impl_.use_case_event_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::control_service::UseCaseEvent>( + arena, *from._impl_.use_case_event_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:control_service.SubscribeUseCaseEventsResponse) +} +inline PROTOBUF_NDEBUG_INLINE SubscribeUseCaseEventsResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + remote_ski_(arena) {} + +inline void SubscribeUseCaseEventsResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, remote_entity_address_), + 0, + offsetof(Impl_, use_case_event_) - + offsetof(Impl_, remote_entity_address_) + + sizeof(Impl_::use_case_event_)); +} +SubscribeUseCaseEventsResponse::~SubscribeUseCaseEventsResponse() { + // @@protoc_insertion_point(destructor:control_service.SubscribeUseCaseEventsResponse) + SharedDtor(*this); +} +inline void SubscribeUseCaseEventsResponse::SharedDtor(MessageLite& self) { + SubscribeUseCaseEventsResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.remote_ski_.Destroy(); + delete this_._impl_.remote_entity_address_; + delete this_._impl_.use_case_event_; + this_._impl_.~Impl_(); +} + +inline void* SubscribeUseCaseEventsResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SubscribeUseCaseEventsResponse(arena); +} +constexpr auto SubscribeUseCaseEventsResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SubscribeUseCaseEventsResponse), + alignof(SubscribeUseCaseEventsResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SubscribeUseCaseEventsResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SubscribeUseCaseEventsResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SubscribeUseCaseEventsResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SubscribeUseCaseEventsResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SubscribeUseCaseEventsResponse::ByteSizeLong, + &SubscribeUseCaseEventsResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_._cached_size_), + false, + }, + &SubscribeUseCaseEventsResponse::kDescriptorMethods, + &descriptor_table_control_5fservice_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SubscribeUseCaseEventsResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 65, 2> SubscribeUseCaseEventsResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _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), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::SubscribeUseCaseEventsResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string remote_ski = 1; + {::_pbi::TcParser::FastUS1, + {10, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.remote_ski_)}}, + // .common_types.EntityAddress remote_entity_address = 2; + {::_pbi::TcParser::FastMtS1, + {18, 0, 0, PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.remote_entity_address_)}}, + // .control_service.UseCaseEvent use_case_event = 3; + {::_pbi::TcParser::FastMtS1, + {26, 1, 1, PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.use_case_event_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string remote_ski = 1; + {PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.remote_ski_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .common_types.EntityAddress remote_entity_address = 2; + {PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.remote_entity_address_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .control_service.UseCaseEvent use_case_event = 3; + {PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.use_case_event_), _Internal::kHasBitsOffset + 1, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::EntityAddress>()}, + {::_pbi::TcParser::GetTable<::control_service::UseCaseEvent>()}, + }}, {{ + "\56\12\0\0\0\0\0\0" + "control_service.SubscribeUseCaseEventsResponse" + "remote_ski" + }}, +}; + +PROTOBUF_NOINLINE void SubscribeUseCaseEventsResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.SubscribeUseCaseEventsResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.remote_ski_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.remote_entity_address_ != nullptr); + _impl_.remote_entity_address_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.use_case_event_ != nullptr); + _impl_.use_case_event_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SubscribeUseCaseEventsResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SubscribeUseCaseEventsResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SubscribeUseCaseEventsResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SubscribeUseCaseEventsResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.SubscribeUseCaseEventsResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // string remote_ski = 1; + if (!this_._internal_remote_ski().empty()) { + const std::string& _s = this_._internal_remote_ski(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.SubscribeUseCaseEventsResponse.remote_ski"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.EntityAddress remote_entity_address = 2; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.remote_entity_address_, this_._impl_.remote_entity_address_->GetCachedSize(), target, + stream); + } + + // .control_service.UseCaseEvent use_case_event = 3; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.use_case_event_, this_._impl_.use_case_event_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.SubscribeUseCaseEventsResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SubscribeUseCaseEventsResponse::ByteSizeLong(const MessageLite& base) { + const SubscribeUseCaseEventsResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SubscribeUseCaseEventsResponse::ByteSizeLong() const { + const SubscribeUseCaseEventsResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.SubscribeUseCaseEventsResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string remote_ski = 1; + if (!this_._internal_remote_ski().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_remote_ski()); + } + } + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .common_types.EntityAddress remote_entity_address = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.remote_entity_address_); + } + // .control_service.UseCaseEvent use_case_event = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.use_case_event_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SubscribeUseCaseEventsResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.SubscribeUseCaseEventsResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_remote_ski().empty()) { + _this->_internal_set_remote_ski(from._internal_remote_ski()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.remote_entity_address_ != nullptr); + if (_this->_impl_.remote_entity_address_ == nullptr) { + _this->_impl_.remote_entity_address_ = + ::google::protobuf::Message::CopyConstruct<::common_types::EntityAddress>(arena, *from._impl_.remote_entity_address_); + } else { + _this->_impl_.remote_entity_address_->MergeFrom(*from._impl_.remote_entity_address_); + } + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(from._impl_.use_case_event_ != nullptr); + if (_this->_impl_.use_case_event_ == nullptr) { + _this->_impl_.use_case_event_ = + ::google::protobuf::Message::CopyConstruct<::control_service::UseCaseEvent>(arena, *from._impl_.use_case_event_); + } else { + _this->_impl_.use_case_event_->MergeFrom(*from._impl_.use_case_event_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SubscribeUseCaseEventsResponse::CopyFrom(const SubscribeUseCaseEventsResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.SubscribeUseCaseEventsResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SubscribeUseCaseEventsResponse::InternalSwap(SubscribeUseCaseEventsResponse* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.remote_ski_, &other->_impl_.remote_ski_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.use_case_event_) + + sizeof(SubscribeUseCaseEventsResponse::_impl_.use_case_event_) + - PROTOBUF_FIELD_OFFSET(SubscribeUseCaseEventsResponse, _impl_.remote_entity_address_)>( + reinterpret_cast(&_impl_.remote_entity_address_), + reinterpret_cast(&other->_impl_.remote_entity_address_)); +} + +::google::protobuf::Metadata SubscribeUseCaseEventsResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +EmptyRequest CreateEmptyRequest() { + EmptyRequest res; + return res; +} + +EmptyResponse CreateEmptyResponse() { + EmptyResponse res; + return res; +} + +SetConfigRequest CreateSetConfigRequest( + uint32_t port, + std::string vendor_code, + std::string device_brand, + std::string device_model, + std::string serial_number, + std::vector device_categories, + control_service::DeviceType::Enum device_type, + std::vector entity_types, + uint32_t heartbeat_timeout_seconds) { + SetConfigRequest res; + res.set_port(port); + res.set_vendor_code(vendor_code); + res.set_device_brand(device_brand); + res.set_device_model(device_model); + res.set_serial_number(serial_number); + res.mutable_device_categories()->Add(device_categories.begin(), device_categories.end()); + res.set_device_type(device_type); + res.mutable_entity_types()->Add(entity_types.begin(), entity_types.end()); + res.set_heartbeat_timeout_seconds(heartbeat_timeout_seconds); + return res; +} + +AddEntityRequest CreateAddEntityRequest( + control_service::EntityType::Enum type, + common_types::EntityAddress* address) { + AddEntityRequest res; + res.set_type(type); + res.set_allocated_address(address); + return res; +} + +RemoveEntityRequest CreateRemoveEntityRequest( + common_types::EntityAddress* address) { + RemoveEntityRequest res; + res.set_allocated_address(address); + return res; +} + +AddUseCaseRequest CreateAddUseCaseRequest( + common_types::EntityAddress* entity_address, + control_service::UseCase* use_case) { + AddUseCaseRequest res; + res.set_allocated_entity_address(entity_address); + res.set_allocated_use_case(use_case); + return res; +} + +AddUseCaseResponse CreateAddUseCaseResponse( + std::string endpoint) { + AddUseCaseResponse res; + res.set_endpoint(endpoint); + return res; +} + +RegisterRemoteSkiRequest CreateRegisterRemoteSkiRequest( + std::string remote_ski) { + RegisterRemoteSkiRequest res; + res.set_remote_ski(remote_ski); + return res; +} + +SubscribeUseCaseEventsRequest CreateSubscribeUseCaseEventsRequest( + common_types::EntityAddress* entity_address, + control_service::UseCase* use_case) { + SubscribeUseCaseEventsRequest res; + res.set_allocated_entity_address(entity_address); + res.set_allocated_use_case(use_case); + return res; +} + +SubscribeUseCaseEventsResponse CreateSubscribeUseCaseEventsResponse( + std::string remote_ski, + common_types::EntityAddress* remote_entity_address, + control_service::UseCaseEvent* use_case_event) { + SubscribeUseCaseEventsResponse res; + res.set_remote_ski(remote_ski); + res.set_allocated_remote_entity_address(remote_entity_address); + res.set_allocated_use_case_event(use_case_event); + return res; +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace control_service +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_control_5fservice_2fmessages_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.h new file mode 100644 index 0000000000..9463598353 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.h @@ -0,0 +1,3530 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: control_service/messages.proto +// Protobuf C++ Version: 5.29.0 + +#ifndef control_5fservice_2fmessages_2eproto_2epb_2eh +#define control_5fservice_2fmessages_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029000 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_bases.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +#include "control_service/types.pb.h" +#include "common_types/types.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_control_5fservice_2fmessages_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_control_5fservice_2fmessages_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_control_5fservice_2fmessages_2eproto; +namespace control_service { +class AddEntityRequest; +struct AddEntityRequestDefaultTypeInternal; +extern AddEntityRequestDefaultTypeInternal _AddEntityRequest_default_instance_; +class AddUseCaseRequest; +struct AddUseCaseRequestDefaultTypeInternal; +extern AddUseCaseRequestDefaultTypeInternal _AddUseCaseRequest_default_instance_; +class AddUseCaseResponse; +struct AddUseCaseResponseDefaultTypeInternal; +extern AddUseCaseResponseDefaultTypeInternal _AddUseCaseResponse_default_instance_; +class EmptyRequest; +struct EmptyRequestDefaultTypeInternal; +extern EmptyRequestDefaultTypeInternal _EmptyRequest_default_instance_; +class EmptyResponse; +struct EmptyResponseDefaultTypeInternal; +extern EmptyResponseDefaultTypeInternal _EmptyResponse_default_instance_; +class RegisterRemoteSkiRequest; +struct RegisterRemoteSkiRequestDefaultTypeInternal; +extern RegisterRemoteSkiRequestDefaultTypeInternal _RegisterRemoteSkiRequest_default_instance_; +class RemoveEntityRequest; +struct RemoveEntityRequestDefaultTypeInternal; +extern RemoveEntityRequestDefaultTypeInternal _RemoveEntityRequest_default_instance_; +class SetConfigRequest; +struct SetConfigRequestDefaultTypeInternal; +extern SetConfigRequestDefaultTypeInternal _SetConfigRequest_default_instance_; +class SubscribeUseCaseEventsRequest; +struct SubscribeUseCaseEventsRequestDefaultTypeInternal; +extern SubscribeUseCaseEventsRequestDefaultTypeInternal _SubscribeUseCaseEventsRequest_default_instance_; +class SubscribeUseCaseEventsResponse; +struct SubscribeUseCaseEventsResponseDefaultTypeInternal; +extern SubscribeUseCaseEventsResponseDefaultTypeInternal _SubscribeUseCaseEventsResponse_default_instance_; +} // namespace control_service +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace control_service { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class SetConfigRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.SetConfigRequest) */ { + public: + inline SetConfigRequest() : SetConfigRequest(nullptr) {} + ~SetConfigRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetConfigRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetConfigRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetConfigRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline SetConfigRequest(const SetConfigRequest& from) : SetConfigRequest(nullptr, from) {} + inline SetConfigRequest(SetConfigRequest&& from) noexcept + : SetConfigRequest(nullptr, std::move(from)) {} + inline SetConfigRequest& operator=(const SetConfigRequest& from) { + CopyFrom(from); + return *this; + } + inline SetConfigRequest& operator=(SetConfigRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetConfigRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetConfigRequest* internal_default_instance() { + return reinterpret_cast( + &_SetConfigRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(SetConfigRequest& a, SetConfigRequest& b) { a.Swap(&b); } + inline void Swap(SetConfigRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetConfigRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetConfigRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetConfigRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetConfigRequest& from) { SetConfigRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetConfigRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.SetConfigRequest"; } + + protected: + explicit SetConfigRequest(::google::protobuf::Arena* arena); + SetConfigRequest(::google::protobuf::Arena* arena, const SetConfigRequest& from); + SetConfigRequest(::google::protobuf::Arena* arena, SetConfigRequest&& from) noexcept + : SetConfigRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kDeviceCategoriesFieldNumber = 6, + kEntityTypesFieldNumber = 8, + kVendorCodeFieldNumber = 2, + kDeviceBrandFieldNumber = 3, + kDeviceModelFieldNumber = 4, + kSerialNumberFieldNumber = 5, + kPortFieldNumber = 1, + kDeviceTypeFieldNumber = 7, + kHeartbeatTimeoutSecondsFieldNumber = 9, + }; + // repeated .control_service.DeviceCategory.Enum device_categories = 6; + int device_categories_size() const; + private: + int _internal_device_categories_size() const; + + public: + void clear_device_categories() ; + public: + ::control_service::DeviceCategory_Enum device_categories(int index) const; + void set_device_categories(int index, ::control_service::DeviceCategory_Enum value); + void add_device_categories(::control_service::DeviceCategory_Enum value); + const ::google::protobuf::RepeatedField& device_categories() const; + ::google::protobuf::RepeatedField* mutable_device_categories(); + + private: + const ::google::protobuf::RepeatedField& _internal_device_categories() const; + ::google::protobuf::RepeatedField* _internal_mutable_device_categories(); + + public: + // repeated .control_service.EntityType.Enum entity_types = 8; + int entity_types_size() const; + private: + int _internal_entity_types_size() const; + + public: + void clear_entity_types() ; + public: + ::control_service::EntityType_Enum entity_types(int index) const; + void set_entity_types(int index, ::control_service::EntityType_Enum value); + void add_entity_types(::control_service::EntityType_Enum value); + const ::google::protobuf::RepeatedField& entity_types() const; + ::google::protobuf::RepeatedField* mutable_entity_types(); + + private: + const ::google::protobuf::RepeatedField& _internal_entity_types() const; + ::google::protobuf::RepeatedField* _internal_mutable_entity_types(); + + public: + // string vendor_code = 2; + void clear_vendor_code() ; + const std::string& vendor_code() const; + template + void set_vendor_code(Arg_&& arg, Args_... args); + std::string* mutable_vendor_code(); + PROTOBUF_NODISCARD std::string* release_vendor_code(); + void set_allocated_vendor_code(std::string* value); + + private: + const std::string& _internal_vendor_code() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_vendor_code( + const std::string& value); + std::string* _internal_mutable_vendor_code(); + + public: + // string device_brand = 3; + void clear_device_brand() ; + const std::string& device_brand() const; + template + void set_device_brand(Arg_&& arg, Args_... args); + std::string* mutable_device_brand(); + PROTOBUF_NODISCARD std::string* release_device_brand(); + void set_allocated_device_brand(std::string* value); + + private: + const std::string& _internal_device_brand() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_brand( + const std::string& value); + std::string* _internal_mutable_device_brand(); + + public: + // string device_model = 4; + void clear_device_model() ; + const std::string& device_model() const; + template + void set_device_model(Arg_&& arg, Args_... args); + std::string* mutable_device_model(); + PROTOBUF_NODISCARD std::string* release_device_model(); + void set_allocated_device_model(std::string* value); + + private: + const std::string& _internal_device_model() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model( + const std::string& value); + std::string* _internal_mutable_device_model(); + + public: + // string serial_number = 5; + void clear_serial_number() ; + const std::string& serial_number() const; + template + void set_serial_number(Arg_&& arg, Args_... args); + std::string* mutable_serial_number(); + PROTOBUF_NODISCARD std::string* release_serial_number(); + void set_allocated_serial_number(std::string* value); + + private: + const std::string& _internal_serial_number() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_serial_number( + const std::string& value); + std::string* _internal_mutable_serial_number(); + + public: + // uint32 port = 1; + void clear_port() ; + ::uint32_t port() const; + void set_port(::uint32_t value); + + private: + ::uint32_t _internal_port() const; + void _internal_set_port(::uint32_t value); + + public: + // .control_service.DeviceType.Enum device_type = 7; + void clear_device_type() ; + ::control_service::DeviceType_Enum device_type() const; + void set_device_type(::control_service::DeviceType_Enum value); + + private: + ::control_service::DeviceType_Enum _internal_device_type() const; + void _internal_set_device_type(::control_service::DeviceType_Enum value); + + public: + // uint32 heartbeat_timeout_seconds = 9; + void clear_heartbeat_timeout_seconds() ; + ::uint32_t heartbeat_timeout_seconds() const; + void set_heartbeat_timeout_seconds(::uint32_t value); + + private: + ::uint32_t _internal_heartbeat_timeout_seconds() const; + void _internal_set_heartbeat_timeout_seconds(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:control_service.SetConfigRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 9, 0, + 97, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetConfigRequest& from_msg); + ::google::protobuf::RepeatedField device_categories_; + ::google::protobuf::internal::CachedSize _device_categories_cached_byte_size_; + ::google::protobuf::RepeatedField entity_types_; + ::google::protobuf::internal::CachedSize _entity_types_cached_byte_size_; + ::google::protobuf::internal::ArenaStringPtr vendor_code_; + ::google::protobuf::internal::ArenaStringPtr device_brand_; + ::google::protobuf::internal::ArenaStringPtr device_model_; + ::google::protobuf::internal::ArenaStringPtr serial_number_; + ::uint32_t port_; + int device_type_; + ::uint32_t heartbeat_timeout_seconds_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class RegisterRemoteSkiRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.RegisterRemoteSkiRequest) */ { + public: + inline RegisterRemoteSkiRequest() : RegisterRemoteSkiRequest(nullptr) {} + ~RegisterRemoteSkiRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RegisterRemoteSkiRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RegisterRemoteSkiRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RegisterRemoteSkiRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RegisterRemoteSkiRequest(const RegisterRemoteSkiRequest& from) : RegisterRemoteSkiRequest(nullptr, from) {} + inline RegisterRemoteSkiRequest(RegisterRemoteSkiRequest&& from) noexcept + : RegisterRemoteSkiRequest(nullptr, std::move(from)) {} + inline RegisterRemoteSkiRequest& operator=(const RegisterRemoteSkiRequest& from) { + CopyFrom(from); + return *this; + } + inline RegisterRemoteSkiRequest& operator=(RegisterRemoteSkiRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RegisterRemoteSkiRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RegisterRemoteSkiRequest* internal_default_instance() { + return reinterpret_cast( + &_RegisterRemoteSkiRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 7; + friend void swap(RegisterRemoteSkiRequest& a, RegisterRemoteSkiRequest& b) { a.Swap(&b); } + inline void Swap(RegisterRemoteSkiRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RegisterRemoteSkiRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RegisterRemoteSkiRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RegisterRemoteSkiRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RegisterRemoteSkiRequest& from) { RegisterRemoteSkiRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RegisterRemoteSkiRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.RegisterRemoteSkiRequest"; } + + protected: + explicit RegisterRemoteSkiRequest(::google::protobuf::Arena* arena); + RegisterRemoteSkiRequest(::google::protobuf::Arena* arena, const RegisterRemoteSkiRequest& from); + RegisterRemoteSkiRequest(::google::protobuf::Arena* arena, RegisterRemoteSkiRequest&& from) noexcept + : RegisterRemoteSkiRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kRemoteSkiFieldNumber = 1, + }; + // string remote_ski = 1; + void clear_remote_ski() ; + const std::string& remote_ski() const; + template + void set_remote_ski(Arg_&& arg, Args_... args); + std::string* mutable_remote_ski(); + PROTOBUF_NODISCARD std::string* release_remote_ski(); + void set_allocated_remote_ski(std::string* value); + + private: + const std::string& _internal_remote_ski() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_ski( + const std::string& value); + std::string* _internal_mutable_remote_ski(); + + public: + // @@protoc_insertion_point(class_scope:control_service.RegisterRemoteSkiRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 59, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RegisterRemoteSkiRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr remote_ski_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class EmptyResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.EmptyResponse) */ { + public: + inline EmptyResponse() : EmptyResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(EmptyResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(EmptyResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR EmptyResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline EmptyResponse(const EmptyResponse& from) : EmptyResponse(nullptr, from) {} + inline EmptyResponse(EmptyResponse&& from) noexcept + : EmptyResponse(nullptr, std::move(from)) {} + inline EmptyResponse& operator=(const EmptyResponse& from) { + CopyFrom(from); + return *this; + } + inline EmptyResponse& operator=(EmptyResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EmptyResponse& default_instance() { + return *internal_default_instance(); + } + static inline const EmptyResponse* internal_default_instance() { + return reinterpret_cast( + &_EmptyResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(EmptyResponse& a, EmptyResponse& b) { a.Swap(&b); } + inline void Swap(EmptyResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EmptyResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EmptyResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const EmptyResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const EmptyResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.EmptyResponse"; } + + protected: + explicit EmptyResponse(::google::protobuf::Arena* arena); + EmptyResponse(::google::protobuf::Arena* arena, const EmptyResponse& from); + EmptyResponse(::google::protobuf::Arena* arena, EmptyResponse&& from) noexcept + : EmptyResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.EmptyResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const EmptyResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class EmptyRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.EmptyRequest) */ { + public: + inline EmptyRequest() : EmptyRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(EmptyRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(EmptyRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR EmptyRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline EmptyRequest(const EmptyRequest& from) : EmptyRequest(nullptr, from) {} + inline EmptyRequest(EmptyRequest&& from) noexcept + : EmptyRequest(nullptr, std::move(from)) {} + inline EmptyRequest& operator=(const EmptyRequest& from) { + CopyFrom(from); + return *this; + } + inline EmptyRequest& operator=(EmptyRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EmptyRequest& default_instance() { + return *internal_default_instance(); + } + static inline const EmptyRequest* internal_default_instance() { + return reinterpret_cast( + &_EmptyRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(EmptyRequest& a, EmptyRequest& b) { a.Swap(&b); } + inline void Swap(EmptyRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EmptyRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EmptyRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const EmptyRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const EmptyRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.EmptyRequest"; } + + protected: + explicit EmptyRequest(::google::protobuf::Arena* arena); + EmptyRequest(::google::protobuf::Arena* arena, const EmptyRequest& from); + EmptyRequest(::google::protobuf::Arena* arena, EmptyRequest&& from) noexcept + : EmptyRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.EmptyRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const EmptyRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class AddUseCaseResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.AddUseCaseResponse) */ { + public: + inline AddUseCaseResponse() : AddUseCaseResponse(nullptr) {} + ~AddUseCaseResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(AddUseCaseResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(AddUseCaseResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR AddUseCaseResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline AddUseCaseResponse(const AddUseCaseResponse& from) : AddUseCaseResponse(nullptr, from) {} + inline AddUseCaseResponse(AddUseCaseResponse&& from) noexcept + : AddUseCaseResponse(nullptr, std::move(from)) {} + inline AddUseCaseResponse& operator=(const AddUseCaseResponse& from) { + CopyFrom(from); + return *this; + } + inline AddUseCaseResponse& operator=(AddUseCaseResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const AddUseCaseResponse& default_instance() { + return *internal_default_instance(); + } + static inline const AddUseCaseResponse* internal_default_instance() { + return reinterpret_cast( + &_AddUseCaseResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(AddUseCaseResponse& a, AddUseCaseResponse& b) { a.Swap(&b); } + inline void Swap(AddUseCaseResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AddUseCaseResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AddUseCaseResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const AddUseCaseResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const AddUseCaseResponse& from) { AddUseCaseResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(AddUseCaseResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.AddUseCaseResponse"; } + + protected: + explicit AddUseCaseResponse(::google::protobuf::Arena* arena); + AddUseCaseResponse(::google::protobuf::Arena* arena, const AddUseCaseResponse& from); + AddUseCaseResponse(::google::protobuf::Arena* arena, AddUseCaseResponse&& from) noexcept + : AddUseCaseResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEndpointFieldNumber = 1, + }; + // string endpoint = 1; + void clear_endpoint() ; + const std::string& endpoint() const; + template + void set_endpoint(Arg_&& arg, Args_... args); + std::string* mutable_endpoint(); + PROTOBUF_NODISCARD std::string* release_endpoint(); + void set_allocated_endpoint(std::string* value); + + private: + const std::string& _internal_endpoint() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint( + const std::string& value); + std::string* _internal_mutable_endpoint(); + + public: + // @@protoc_insertion_point(class_scope:control_service.AddUseCaseResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 51, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const AddUseCaseResponse& from_msg); + ::google::protobuf::internal::ArenaStringPtr endpoint_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SubscribeUseCaseEventsRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.SubscribeUseCaseEventsRequest) */ { + public: + inline SubscribeUseCaseEventsRequest() : SubscribeUseCaseEventsRequest(nullptr) {} + ~SubscribeUseCaseEventsRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SubscribeUseCaseEventsRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SubscribeUseCaseEventsRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SubscribeUseCaseEventsRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline SubscribeUseCaseEventsRequest(const SubscribeUseCaseEventsRequest& from) : SubscribeUseCaseEventsRequest(nullptr, from) {} + inline SubscribeUseCaseEventsRequest(SubscribeUseCaseEventsRequest&& from) noexcept + : SubscribeUseCaseEventsRequest(nullptr, std::move(from)) {} + inline SubscribeUseCaseEventsRequest& operator=(const SubscribeUseCaseEventsRequest& from) { + CopyFrom(from); + return *this; + } + inline SubscribeUseCaseEventsRequest& operator=(SubscribeUseCaseEventsRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SubscribeUseCaseEventsRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SubscribeUseCaseEventsRequest* internal_default_instance() { + return reinterpret_cast( + &_SubscribeUseCaseEventsRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + friend void swap(SubscribeUseCaseEventsRequest& a, SubscribeUseCaseEventsRequest& b) { a.Swap(&b); } + inline void Swap(SubscribeUseCaseEventsRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SubscribeUseCaseEventsRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SubscribeUseCaseEventsRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SubscribeUseCaseEventsRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SubscribeUseCaseEventsRequest& from) { SubscribeUseCaseEventsRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SubscribeUseCaseEventsRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.SubscribeUseCaseEventsRequest"; } + + protected: + explicit SubscribeUseCaseEventsRequest(::google::protobuf::Arena* arena); + SubscribeUseCaseEventsRequest(::google::protobuf::Arena* arena, const SubscribeUseCaseEventsRequest& from); + SubscribeUseCaseEventsRequest(::google::protobuf::Arena* arena, SubscribeUseCaseEventsRequest&& from) noexcept + : SubscribeUseCaseEventsRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEntityAddressFieldNumber = 1, + kUseCaseFieldNumber = 2, + }; + // .common_types.EntityAddress entity_address = 1; + bool has_entity_address() const; + void clear_entity_address() ; + const ::common_types::EntityAddress& entity_address() const; + PROTOBUF_NODISCARD ::common_types::EntityAddress* release_entity_address(); + ::common_types::EntityAddress* mutable_entity_address(); + void set_allocated_entity_address(::common_types::EntityAddress* value); + void unsafe_arena_set_allocated_entity_address(::common_types::EntityAddress* value); + ::common_types::EntityAddress* unsafe_arena_release_entity_address(); + + private: + const ::common_types::EntityAddress& _internal_entity_address() const; + ::common_types::EntityAddress* _internal_mutable_entity_address(); + + public: + // .control_service.UseCase use_case = 2; + bool has_use_case() const; + void clear_use_case() ; + const ::control_service::UseCase& use_case() const; + PROTOBUF_NODISCARD ::control_service::UseCase* release_use_case(); + ::control_service::UseCase* mutable_use_case(); + void set_allocated_use_case(::control_service::UseCase* value); + void unsafe_arena_set_allocated_use_case(::control_service::UseCase* value); + ::control_service::UseCase* unsafe_arena_release_use_case(); + + private: + const ::control_service::UseCase& _internal_use_case() const; + ::control_service::UseCase* _internal_mutable_use_case(); + + public: + // @@protoc_insertion_point(class_scope:control_service.SubscribeUseCaseEventsRequest) + 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; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SubscribeUseCaseEventsRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::common_types::EntityAddress* entity_address_; + ::control_service::UseCase* use_case_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class RemoveEntityRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.RemoveEntityRequest) */ { + public: + inline RemoveEntityRequest() : RemoveEntityRequest(nullptr) {} + ~RemoveEntityRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RemoveEntityRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RemoveEntityRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RemoveEntityRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline RemoveEntityRequest(const RemoveEntityRequest& from) : RemoveEntityRequest(nullptr, from) {} + inline RemoveEntityRequest(RemoveEntityRequest&& from) noexcept + : RemoveEntityRequest(nullptr, std::move(from)) {} + inline RemoveEntityRequest& operator=(const RemoveEntityRequest& from) { + CopyFrom(from); + return *this; + } + inline RemoveEntityRequest& operator=(RemoveEntityRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RemoveEntityRequest& default_instance() { + return *internal_default_instance(); + } + static inline const RemoveEntityRequest* internal_default_instance() { + return reinterpret_cast( + &_RemoveEntityRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + friend void swap(RemoveEntityRequest& a, RemoveEntityRequest& b) { a.Swap(&b); } + inline void Swap(RemoveEntityRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RemoveEntityRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RemoveEntityRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const RemoveEntityRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const RemoveEntityRequest& from) { RemoveEntityRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RemoveEntityRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.RemoveEntityRequest"; } + + protected: + explicit RemoveEntityRequest(::google::protobuf::Arena* arena); + RemoveEntityRequest(::google::protobuf::Arena* arena, const RemoveEntityRequest& from); + RemoveEntityRequest(::google::protobuf::Arena* arena, RemoveEntityRequest&& from) noexcept + : RemoveEntityRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kAddressFieldNumber = 1, + }; + // .common_types.EntityAddress address = 1; + bool has_address() const; + void clear_address() ; + const ::common_types::EntityAddress& address() const; + PROTOBUF_NODISCARD ::common_types::EntityAddress* release_address(); + ::common_types::EntityAddress* mutable_address(); + void set_allocated_address(::common_types::EntityAddress* value); + void unsafe_arena_set_allocated_address(::common_types::EntityAddress* value); + ::common_types::EntityAddress* unsafe_arena_release_address(); + + private: + const ::common_types::EntityAddress& _internal_address() const; + ::common_types::EntityAddress* _internal_mutable_address(); + + public: + // @@protoc_insertion_point(class_scope:control_service.RemoveEntityRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RemoveEntityRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::common_types::EntityAddress* address_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class AddUseCaseRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.AddUseCaseRequest) */ { + public: + inline AddUseCaseRequest() : AddUseCaseRequest(nullptr) {} + ~AddUseCaseRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(AddUseCaseRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(AddUseCaseRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR AddUseCaseRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline AddUseCaseRequest(const AddUseCaseRequest& from) : AddUseCaseRequest(nullptr, from) {} + inline AddUseCaseRequest(AddUseCaseRequest&& from) noexcept + : AddUseCaseRequest(nullptr, std::move(from)) {} + inline AddUseCaseRequest& operator=(const AddUseCaseRequest& from) { + CopyFrom(from); + return *this; + } + inline AddUseCaseRequest& operator=(AddUseCaseRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const AddUseCaseRequest& default_instance() { + return *internal_default_instance(); + } + static inline const AddUseCaseRequest* internal_default_instance() { + return reinterpret_cast( + &_AddUseCaseRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 5; + friend void swap(AddUseCaseRequest& a, AddUseCaseRequest& b) { a.Swap(&b); } + inline void Swap(AddUseCaseRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AddUseCaseRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AddUseCaseRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const AddUseCaseRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const AddUseCaseRequest& from) { AddUseCaseRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(AddUseCaseRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.AddUseCaseRequest"; } + + protected: + explicit AddUseCaseRequest(::google::protobuf::Arena* arena); + AddUseCaseRequest(::google::protobuf::Arena* arena, const AddUseCaseRequest& from); + AddUseCaseRequest(::google::protobuf::Arena* arena, AddUseCaseRequest&& from) noexcept + : AddUseCaseRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEntityAddressFieldNumber = 1, + kUseCaseFieldNumber = 2, + }; + // .common_types.EntityAddress entity_address = 1; + bool has_entity_address() const; + void clear_entity_address() ; + const ::common_types::EntityAddress& entity_address() const; + PROTOBUF_NODISCARD ::common_types::EntityAddress* release_entity_address(); + ::common_types::EntityAddress* mutable_entity_address(); + void set_allocated_entity_address(::common_types::EntityAddress* value); + void unsafe_arena_set_allocated_entity_address(::common_types::EntityAddress* value); + ::common_types::EntityAddress* unsafe_arena_release_entity_address(); + + private: + const ::common_types::EntityAddress& _internal_entity_address() const; + ::common_types::EntityAddress* _internal_mutable_entity_address(); + + public: + // .control_service.UseCase use_case = 2; + bool has_use_case() const; + void clear_use_case() ; + const ::control_service::UseCase& use_case() const; + PROTOBUF_NODISCARD ::control_service::UseCase* release_use_case(); + ::control_service::UseCase* mutable_use_case(); + void set_allocated_use_case(::control_service::UseCase* value); + void unsafe_arena_set_allocated_use_case(::control_service::UseCase* value); + ::control_service::UseCase* unsafe_arena_release_use_case(); + + private: + const ::control_service::UseCase& _internal_use_case() const; + ::control_service::UseCase* _internal_mutable_use_case(); + + public: + // @@protoc_insertion_point(class_scope:control_service.AddUseCaseRequest) + 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; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const AddUseCaseRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::common_types::EntityAddress* entity_address_; + ::control_service::UseCase* use_case_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class AddEntityRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.AddEntityRequest) */ { + public: + inline AddEntityRequest() : AddEntityRequest(nullptr) {} + ~AddEntityRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(AddEntityRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(AddEntityRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR AddEntityRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline AddEntityRequest(const AddEntityRequest& from) : AddEntityRequest(nullptr, from) {} + inline AddEntityRequest(AddEntityRequest&& from) noexcept + : AddEntityRequest(nullptr, std::move(from)) {} + inline AddEntityRequest& operator=(const AddEntityRequest& from) { + CopyFrom(from); + return *this; + } + inline AddEntityRequest& operator=(AddEntityRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const AddEntityRequest& default_instance() { + return *internal_default_instance(); + } + static inline const AddEntityRequest* internal_default_instance() { + return reinterpret_cast( + &_AddEntityRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(AddEntityRequest& a, AddEntityRequest& b) { a.Swap(&b); } + inline void Swap(AddEntityRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AddEntityRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AddEntityRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const AddEntityRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const AddEntityRequest& from) { AddEntityRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(AddEntityRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.AddEntityRequest"; } + + protected: + explicit AddEntityRequest(::google::protobuf::Arena* arena); + AddEntityRequest(::google::protobuf::Arena* arena, const AddEntityRequest& from); + AddEntityRequest(::google::protobuf::Arena* arena, AddEntityRequest&& from) noexcept + : AddEntityRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kAddressFieldNumber = 2, + kTypeFieldNumber = 1, + }; + // .common_types.EntityAddress address = 2; + bool has_address() const; + void clear_address() ; + const ::common_types::EntityAddress& address() const; + PROTOBUF_NODISCARD ::common_types::EntityAddress* release_address(); + ::common_types::EntityAddress* mutable_address(); + void set_allocated_address(::common_types::EntityAddress* value); + void unsafe_arena_set_allocated_address(::common_types::EntityAddress* value); + ::common_types::EntityAddress* unsafe_arena_release_address(); + + private: + const ::common_types::EntityAddress& _internal_address() const; + ::common_types::EntityAddress* _internal_mutable_address(); + + public: + // .control_service.EntityType.Enum type = 1; + void clear_type() ; + ::control_service::EntityType_Enum type() const; + void set_type(::control_service::EntityType_Enum value); + + private: + ::control_service::EntityType_Enum _internal_type() const; + void _internal_set_type(::control_service::EntityType_Enum value); + + public: + // @@protoc_insertion_point(class_scope:control_service.AddEntityRequest) + 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; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const AddEntityRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::common_types::EntityAddress* address_; + int type_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SubscribeUseCaseEventsResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.SubscribeUseCaseEventsResponse) */ { + public: + inline SubscribeUseCaseEventsResponse() : SubscribeUseCaseEventsResponse(nullptr) {} + ~SubscribeUseCaseEventsResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SubscribeUseCaseEventsResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SubscribeUseCaseEventsResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SubscribeUseCaseEventsResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline SubscribeUseCaseEventsResponse(const SubscribeUseCaseEventsResponse& from) : SubscribeUseCaseEventsResponse(nullptr, from) {} + inline SubscribeUseCaseEventsResponse(SubscribeUseCaseEventsResponse&& from) noexcept + : SubscribeUseCaseEventsResponse(nullptr, std::move(from)) {} + inline SubscribeUseCaseEventsResponse& operator=(const SubscribeUseCaseEventsResponse& from) { + CopyFrom(from); + return *this; + } + inline SubscribeUseCaseEventsResponse& operator=(SubscribeUseCaseEventsResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SubscribeUseCaseEventsResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SubscribeUseCaseEventsResponse* internal_default_instance() { + return reinterpret_cast( + &_SubscribeUseCaseEventsResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 9; + friend void swap(SubscribeUseCaseEventsResponse& a, SubscribeUseCaseEventsResponse& b) { a.Swap(&b); } + inline void Swap(SubscribeUseCaseEventsResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SubscribeUseCaseEventsResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SubscribeUseCaseEventsResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SubscribeUseCaseEventsResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SubscribeUseCaseEventsResponse& from) { SubscribeUseCaseEventsResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SubscribeUseCaseEventsResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.SubscribeUseCaseEventsResponse"; } + + protected: + explicit SubscribeUseCaseEventsResponse(::google::protobuf::Arena* arena); + SubscribeUseCaseEventsResponse(::google::protobuf::Arena* arena, const SubscribeUseCaseEventsResponse& from); + SubscribeUseCaseEventsResponse(::google::protobuf::Arena* arena, SubscribeUseCaseEventsResponse&& from) noexcept + : SubscribeUseCaseEventsResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kRemoteSkiFieldNumber = 1, + kRemoteEntityAddressFieldNumber = 2, + kUseCaseEventFieldNumber = 3, + }; + // string remote_ski = 1; + void clear_remote_ski() ; + const std::string& remote_ski() const; + template + void set_remote_ski(Arg_&& arg, Args_... args); + std::string* mutable_remote_ski(); + PROTOBUF_NODISCARD std::string* release_remote_ski(); + void set_allocated_remote_ski(std::string* value); + + private: + const std::string& _internal_remote_ski() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_ski( + const std::string& value); + std::string* _internal_mutable_remote_ski(); + + public: + // .common_types.EntityAddress remote_entity_address = 2; + bool has_remote_entity_address() const; + void clear_remote_entity_address() ; + const ::common_types::EntityAddress& remote_entity_address() const; + PROTOBUF_NODISCARD ::common_types::EntityAddress* release_remote_entity_address(); + ::common_types::EntityAddress* mutable_remote_entity_address(); + void set_allocated_remote_entity_address(::common_types::EntityAddress* value); + void unsafe_arena_set_allocated_remote_entity_address(::common_types::EntityAddress* value); + ::common_types::EntityAddress* unsafe_arena_release_remote_entity_address(); + + private: + const ::common_types::EntityAddress& _internal_remote_entity_address() const; + ::common_types::EntityAddress* _internal_mutable_remote_entity_address(); + + public: + // .control_service.UseCaseEvent use_case_event = 3; + bool has_use_case_event() const; + void clear_use_case_event() ; + const ::control_service::UseCaseEvent& use_case_event() const; + PROTOBUF_NODISCARD ::control_service::UseCaseEvent* release_use_case_event(); + ::control_service::UseCaseEvent* mutable_use_case_event(); + void set_allocated_use_case_event(::control_service::UseCaseEvent* value); + void unsafe_arena_set_allocated_use_case_event(::control_service::UseCaseEvent* value); + ::control_service::UseCaseEvent* unsafe_arena_release_use_case_event(); + + private: + const ::control_service::UseCaseEvent& _internal_use_case_event() const; + ::control_service::UseCaseEvent* _internal_mutable_use_case_event(); + + public: + // @@protoc_insertion_point(class_scope:control_service.SubscribeUseCaseEventsResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 2, + 65, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SubscribeUseCaseEventsResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr remote_ski_; + ::common_types::EntityAddress* remote_entity_address_; + ::control_service::UseCaseEvent* use_case_event_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2fmessages_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// EmptyRequest + +// ------------------------------------------------------------------- + +// EmptyResponse + +// ------------------------------------------------------------------- + +// SetConfigRequest + +// uint32 port = 1; +inline void SetConfigRequest::clear_port() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = 0u; +} +inline ::uint32_t SetConfigRequest::port() const { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.port) + return _internal_port(); +} +inline void SetConfigRequest::set_port(::uint32_t value) { + _internal_set_port(value); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.port) +} +inline ::uint32_t SetConfigRequest::_internal_port() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.port_; +} +inline void SetConfigRequest::_internal_set_port(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = value; +} + +// string vendor_code = 2; +inline void SetConfigRequest::clear_vendor_code() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vendor_code_.ClearToEmpty(); +} +inline const std::string& SetConfigRequest::vendor_code() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.vendor_code) + return _internal_vendor_code(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SetConfigRequest::set_vendor_code(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vendor_code_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.vendor_code) +} +inline std::string* SetConfigRequest::mutable_vendor_code() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_vendor_code(); + // @@protoc_insertion_point(field_mutable:control_service.SetConfigRequest.vendor_code) + return _s; +} +inline const std::string& SetConfigRequest::_internal_vendor_code() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.vendor_code_.Get(); +} +inline void SetConfigRequest::_internal_set_vendor_code(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vendor_code_.Set(value, GetArena()); +} +inline std::string* SetConfigRequest::_internal_mutable_vendor_code() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.vendor_code_.Mutable( GetArena()); +} +inline std::string* SetConfigRequest::release_vendor_code() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SetConfigRequest.vendor_code) + return _impl_.vendor_code_.Release(); +} +inline void SetConfigRequest::set_allocated_vendor_code(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.vendor_code_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.vendor_code_.IsDefault()) { + _impl_.vendor_code_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.SetConfigRequest.vendor_code) +} + +// string device_brand = 3; +inline void SetConfigRequest::clear_device_brand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_brand_.ClearToEmpty(); +} +inline const std::string& SetConfigRequest::device_brand() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.device_brand) + return _internal_device_brand(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SetConfigRequest::set_device_brand(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_brand_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.device_brand) +} +inline std::string* SetConfigRequest::mutable_device_brand() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_device_brand(); + // @@protoc_insertion_point(field_mutable:control_service.SetConfigRequest.device_brand) + return _s; +} +inline const std::string& SetConfigRequest::_internal_device_brand() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.device_brand_.Get(); +} +inline void SetConfigRequest::_internal_set_device_brand(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_brand_.Set(value, GetArena()); +} +inline std::string* SetConfigRequest::_internal_mutable_device_brand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.device_brand_.Mutable( GetArena()); +} +inline std::string* SetConfigRequest::release_device_brand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SetConfigRequest.device_brand) + return _impl_.device_brand_.Release(); +} +inline void SetConfigRequest::set_allocated_device_brand(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_brand_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.device_brand_.IsDefault()) { + _impl_.device_brand_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.SetConfigRequest.device_brand) +} + +// string device_model = 4; +inline void SetConfigRequest::clear_device_model() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_model_.ClearToEmpty(); +} +inline const std::string& SetConfigRequest::device_model() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.device_model) + return _internal_device_model(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SetConfigRequest::set_device_model(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_model_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.device_model) +} +inline std::string* SetConfigRequest::mutable_device_model() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_device_model(); + // @@protoc_insertion_point(field_mutable:control_service.SetConfigRequest.device_model) + return _s; +} +inline const std::string& SetConfigRequest::_internal_device_model() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.device_model_.Get(); +} +inline void SetConfigRequest::_internal_set_device_model(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_model_.Set(value, GetArena()); +} +inline std::string* SetConfigRequest::_internal_mutable_device_model() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.device_model_.Mutable( GetArena()); +} +inline std::string* SetConfigRequest::release_device_model() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SetConfigRequest.device_model) + return _impl_.device_model_.Release(); +} +inline void SetConfigRequest::set_allocated_device_model(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_model_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.device_model_.IsDefault()) { + _impl_.device_model_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.SetConfigRequest.device_model) +} + +// string serial_number = 5; +inline void SetConfigRequest::clear_serial_number() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.serial_number_.ClearToEmpty(); +} +inline const std::string& SetConfigRequest::serial_number() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.serial_number) + return _internal_serial_number(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SetConfigRequest::set_serial_number(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.serial_number_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.serial_number) +} +inline std::string* SetConfigRequest::mutable_serial_number() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_serial_number(); + // @@protoc_insertion_point(field_mutable:control_service.SetConfigRequest.serial_number) + return _s; +} +inline const std::string& SetConfigRequest::_internal_serial_number() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.serial_number_.Get(); +} +inline void SetConfigRequest::_internal_set_serial_number(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.serial_number_.Set(value, GetArena()); +} +inline std::string* SetConfigRequest::_internal_mutable_serial_number() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.serial_number_.Mutable( GetArena()); +} +inline std::string* SetConfigRequest::release_serial_number() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SetConfigRequest.serial_number) + return _impl_.serial_number_.Release(); +} +inline void SetConfigRequest::set_allocated_serial_number(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.serial_number_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.serial_number_.IsDefault()) { + _impl_.serial_number_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.SetConfigRequest.serial_number) +} + +// repeated .control_service.DeviceCategory.Enum device_categories = 6; +inline int SetConfigRequest::_internal_device_categories_size() const { + return _internal_device_categories().size(); +} +inline int SetConfigRequest::device_categories_size() const { + return _internal_device_categories_size(); +} +inline void SetConfigRequest::clear_device_categories() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_categories_.Clear(); +} +inline ::control_service::DeviceCategory_Enum SetConfigRequest::device_categories(int index) const { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.device_categories) + return static_cast<::control_service::DeviceCategory_Enum>(_internal_device_categories().Get(index)); +} +inline void SetConfigRequest::set_device_categories(int index, ::control_service::DeviceCategory_Enum value) { + _internal_mutable_device_categories()->Set(index, value); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.device_categories) +} +inline void SetConfigRequest::add_device_categories(::control_service::DeviceCategory_Enum value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_device_categories()->Add(value); + // @@protoc_insertion_point(field_add:control_service.SetConfigRequest.device_categories) +} +inline const ::google::protobuf::RepeatedField& SetConfigRequest::device_categories() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:control_service.SetConfigRequest.device_categories) + return _internal_device_categories(); +} +inline ::google::protobuf::RepeatedField* SetConfigRequest::mutable_device_categories() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:control_service.SetConfigRequest.device_categories) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_device_categories(); +} +inline const ::google::protobuf::RepeatedField& SetConfigRequest::_internal_device_categories() + const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.device_categories_; +} +inline ::google::protobuf::RepeatedField* SetConfigRequest::_internal_mutable_device_categories() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.device_categories_; +} + +// .control_service.DeviceType.Enum device_type = 7; +inline void SetConfigRequest::clear_device_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_type_ = 0; +} +inline ::control_service::DeviceType_Enum SetConfigRequest::device_type() const { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.device_type) + return _internal_device_type(); +} +inline void SetConfigRequest::set_device_type(::control_service::DeviceType_Enum value) { + _internal_set_device_type(value); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.device_type) +} +inline ::control_service::DeviceType_Enum SetConfigRequest::_internal_device_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::control_service::DeviceType_Enum>(_impl_.device_type_); +} +inline void SetConfigRequest::_internal_set_device_type(::control_service::DeviceType_Enum value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.device_type_ = value; +} + +// repeated .control_service.EntityType.Enum entity_types = 8; +inline int SetConfigRequest::_internal_entity_types_size() const { + return _internal_entity_types().size(); +} +inline int SetConfigRequest::entity_types_size() const { + return _internal_entity_types_size(); +} +inline void SetConfigRequest::clear_entity_types() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.entity_types_.Clear(); +} +inline ::control_service::EntityType_Enum SetConfigRequest::entity_types(int index) const { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.entity_types) + return static_cast<::control_service::EntityType_Enum>(_internal_entity_types().Get(index)); +} +inline void SetConfigRequest::set_entity_types(int index, ::control_service::EntityType_Enum value) { + _internal_mutable_entity_types()->Set(index, value); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.entity_types) +} +inline void SetConfigRequest::add_entity_types(::control_service::EntityType_Enum value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_entity_types()->Add(value); + // @@protoc_insertion_point(field_add:control_service.SetConfigRequest.entity_types) +} +inline const ::google::protobuf::RepeatedField& SetConfigRequest::entity_types() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:control_service.SetConfigRequest.entity_types) + return _internal_entity_types(); +} +inline ::google::protobuf::RepeatedField* SetConfigRequest::mutable_entity_types() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:control_service.SetConfigRequest.entity_types) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_entity_types(); +} +inline const ::google::protobuf::RepeatedField& SetConfigRequest::_internal_entity_types() + const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.entity_types_; +} +inline ::google::protobuf::RepeatedField* SetConfigRequest::_internal_mutable_entity_types() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.entity_types_; +} + +// uint32 heartbeat_timeout_seconds = 9; +inline void SetConfigRequest::clear_heartbeat_timeout_seconds() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.heartbeat_timeout_seconds_ = 0u; +} +inline ::uint32_t SetConfigRequest::heartbeat_timeout_seconds() const { + // @@protoc_insertion_point(field_get:control_service.SetConfigRequest.heartbeat_timeout_seconds) + return _internal_heartbeat_timeout_seconds(); +} +inline void SetConfigRequest::set_heartbeat_timeout_seconds(::uint32_t value) { + _internal_set_heartbeat_timeout_seconds(value); + // @@protoc_insertion_point(field_set:control_service.SetConfigRequest.heartbeat_timeout_seconds) +} +inline ::uint32_t SetConfigRequest::_internal_heartbeat_timeout_seconds() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.heartbeat_timeout_seconds_; +} +inline void SetConfigRequest::_internal_set_heartbeat_timeout_seconds(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.heartbeat_timeout_seconds_ = value; +} + +// ------------------------------------------------------------------- + +// AddEntityRequest + +// .control_service.EntityType.Enum type = 1; +inline void AddEntityRequest::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0; +} +inline ::control_service::EntityType_Enum AddEntityRequest::type() const { + // @@protoc_insertion_point(field_get:control_service.AddEntityRequest.type) + return _internal_type(); +} +inline void AddEntityRequest::set_type(::control_service::EntityType_Enum value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:control_service.AddEntityRequest.type) +} +inline ::control_service::EntityType_Enum AddEntityRequest::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::control_service::EntityType_Enum>(_impl_.type_); +} +inline void AddEntityRequest::_internal_set_type(::control_service::EntityType_Enum value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// .common_types.EntityAddress address = 2; +inline bool AddEntityRequest::has_address() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); + return value; +} +inline const ::common_types::EntityAddress& AddEntityRequest::_internal_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::EntityAddress* p = _impl_.address_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_EntityAddress_default_instance_); +} +inline const ::common_types::EntityAddress& AddEntityRequest::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.AddEntityRequest.address) + return _internal_address(); +} +inline void AddEntityRequest::unsafe_arena_set_allocated_address(::common_types::EntityAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); + } + _impl_.address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.AddEntityRequest.address) +} +inline ::common_types::EntityAddress* AddEntityRequest::release_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* released = _impl_.address_; + _impl_.address_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::EntityAddress* AddEntityRequest::unsafe_arena_release_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.AddEntityRequest.address) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* temp = _impl_.address_; + _impl_.address_ = nullptr; + return temp; +} +inline ::common_types::EntityAddress* AddEntityRequest::_internal_mutable_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.address_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::EntityAddress>(GetArena()); + _impl_.address_ = reinterpret_cast<::common_types::EntityAddress*>(p); + } + return _impl_.address_; +} +inline ::common_types::EntityAddress* AddEntityRequest::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::EntityAddress* _msg = _internal_mutable_address(); + // @@protoc_insertion_point(field_mutable:control_service.AddEntityRequest.address) + return _msg; +} +inline void AddEntityRequest::set_allocated_address(::common_types::EntityAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.AddEntityRequest.address) +} + +// ------------------------------------------------------------------- + +// RemoveEntityRequest + +// .common_types.EntityAddress address = 1; +inline bool RemoveEntityRequest::has_address() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); + return value; +} +inline const ::common_types::EntityAddress& RemoveEntityRequest::_internal_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::EntityAddress* p = _impl_.address_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_EntityAddress_default_instance_); +} +inline const ::common_types::EntityAddress& RemoveEntityRequest::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.RemoveEntityRequest.address) + return _internal_address(); +} +inline void RemoveEntityRequest::unsafe_arena_set_allocated_address(::common_types::EntityAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); + } + _impl_.address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.RemoveEntityRequest.address) +} +inline ::common_types::EntityAddress* RemoveEntityRequest::release_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* released = _impl_.address_; + _impl_.address_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::EntityAddress* RemoveEntityRequest::unsafe_arena_release_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.RemoveEntityRequest.address) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* temp = _impl_.address_; + _impl_.address_ = nullptr; + return temp; +} +inline ::common_types::EntityAddress* RemoveEntityRequest::_internal_mutable_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.address_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::EntityAddress>(GetArena()); + _impl_.address_ = reinterpret_cast<::common_types::EntityAddress*>(p); + } + return _impl_.address_; +} +inline ::common_types::EntityAddress* RemoveEntityRequest::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::EntityAddress* _msg = _internal_mutable_address(); + // @@protoc_insertion_point(field_mutable:control_service.RemoveEntityRequest.address) + return _msg; +} +inline void RemoveEntityRequest::set_allocated_address(::common_types::EntityAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.RemoveEntityRequest.address) +} + +// ------------------------------------------------------------------- + +// AddUseCaseRequest + +// .common_types.EntityAddress entity_address = 1; +inline bool AddUseCaseRequest::has_entity_address() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.entity_address_ != nullptr); + return value; +} +inline const ::common_types::EntityAddress& AddUseCaseRequest::_internal_entity_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::EntityAddress* p = _impl_.entity_address_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_EntityAddress_default_instance_); +} +inline const ::common_types::EntityAddress& AddUseCaseRequest::entity_address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.AddUseCaseRequest.entity_address) + return _internal_entity_address(); +} +inline void AddUseCaseRequest::unsafe_arena_set_allocated_entity_address(::common_types::EntityAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entity_address_); + } + _impl_.entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.AddUseCaseRequest.entity_address) +} +inline ::common_types::EntityAddress* AddUseCaseRequest::release_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* released = _impl_.entity_address_; + _impl_.entity_address_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::EntityAddress* AddUseCaseRequest::unsafe_arena_release_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.AddUseCaseRequest.entity_address) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* temp = _impl_.entity_address_; + _impl_.entity_address_ = nullptr; + return temp; +} +inline ::common_types::EntityAddress* AddUseCaseRequest::_internal_mutable_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.entity_address_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::EntityAddress>(GetArena()); + _impl_.entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(p); + } + return _impl_.entity_address_; +} +inline ::common_types::EntityAddress* AddUseCaseRequest::mutable_entity_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::EntityAddress* _msg = _internal_mutable_entity_address(); + // @@protoc_insertion_point(field_mutable:control_service.AddUseCaseRequest.entity_address) + return _msg; +} +inline void AddUseCaseRequest::set_allocated_entity_address(::common_types::EntityAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entity_address_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.AddUseCaseRequest.entity_address) +} + +// .control_service.UseCase use_case = 2; +inline bool AddUseCaseRequest::has_use_case() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.use_case_ != nullptr); + return value; +} +inline const ::control_service::UseCase& AddUseCaseRequest::_internal_use_case() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::control_service::UseCase* p = _impl_.use_case_; + return p != nullptr ? *p : reinterpret_cast(::control_service::_UseCase_default_instance_); +} +inline const ::control_service::UseCase& AddUseCaseRequest::use_case() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.AddUseCaseRequest.use_case) + return _internal_use_case(); +} +inline void AddUseCaseRequest::unsafe_arena_set_allocated_use_case(::control_service::UseCase* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_); + } + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.AddUseCaseRequest.use_case) +} +inline ::control_service::UseCase* AddUseCaseRequest::release_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::control_service::UseCase* released = _impl_.use_case_; + _impl_.use_case_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::control_service::UseCase* AddUseCaseRequest::unsafe_arena_release_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.AddUseCaseRequest.use_case) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::control_service::UseCase* temp = _impl_.use_case_; + _impl_.use_case_ = nullptr; + return temp; +} +inline ::control_service::UseCase* AddUseCaseRequest::_internal_mutable_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::control_service::UseCase>(GetArena()); + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(p); + } + return _impl_.use_case_; +} +inline ::control_service::UseCase* AddUseCaseRequest::mutable_use_case() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000002u; + ::control_service::UseCase* _msg = _internal_mutable_use_case(); + // @@protoc_insertion_point(field_mutable:control_service.AddUseCaseRequest.use_case) + return _msg; +} +inline void AddUseCaseRequest::set_allocated_use_case(::control_service::UseCase* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.AddUseCaseRequest.use_case) +} + +// ------------------------------------------------------------------- + +// AddUseCaseResponse + +// string endpoint = 1; +inline void AddUseCaseResponse::clear_endpoint() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.endpoint_.ClearToEmpty(); +} +inline const std::string& AddUseCaseResponse::endpoint() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.AddUseCaseResponse.endpoint) + return _internal_endpoint(); +} +template +inline PROTOBUF_ALWAYS_INLINE void AddUseCaseResponse::set_endpoint(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.endpoint_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.AddUseCaseResponse.endpoint) +} +inline std::string* AddUseCaseResponse::mutable_endpoint() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_endpoint(); + // @@protoc_insertion_point(field_mutable:control_service.AddUseCaseResponse.endpoint) + return _s; +} +inline const std::string& AddUseCaseResponse::_internal_endpoint() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.endpoint_.Get(); +} +inline void AddUseCaseResponse::_internal_set_endpoint(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.endpoint_.Set(value, GetArena()); +} +inline std::string* AddUseCaseResponse::_internal_mutable_endpoint() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.endpoint_.Mutable( GetArena()); +} +inline std::string* AddUseCaseResponse::release_endpoint() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.AddUseCaseResponse.endpoint) + return _impl_.endpoint_.Release(); +} +inline void AddUseCaseResponse::set_allocated_endpoint(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.endpoint_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.endpoint_.IsDefault()) { + _impl_.endpoint_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.AddUseCaseResponse.endpoint) +} + +// ------------------------------------------------------------------- + +// RegisterRemoteSkiRequest + +// string remote_ski = 1; +inline void RegisterRemoteSkiRequest::clear_remote_ski() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.ClearToEmpty(); +} +inline const std::string& RegisterRemoteSkiRequest::remote_ski() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.RegisterRemoteSkiRequest.remote_ski) + return _internal_remote_ski(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RegisterRemoteSkiRequest::set_remote_ski(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.RegisterRemoteSkiRequest.remote_ski) +} +inline std::string* RegisterRemoteSkiRequest::mutable_remote_ski() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_remote_ski(); + // @@protoc_insertion_point(field_mutable:control_service.RegisterRemoteSkiRequest.remote_ski) + return _s; +} +inline const std::string& RegisterRemoteSkiRequest::_internal_remote_ski() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.remote_ski_.Get(); +} +inline void RegisterRemoteSkiRequest::_internal_set_remote_ski(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.Set(value, GetArena()); +} +inline std::string* RegisterRemoteSkiRequest::_internal_mutable_remote_ski() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.remote_ski_.Mutable( GetArena()); +} +inline std::string* RegisterRemoteSkiRequest::release_remote_ski() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.RegisterRemoteSkiRequest.remote_ski) + return _impl_.remote_ski_.Release(); +} +inline void RegisterRemoteSkiRequest::set_allocated_remote_ski(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.remote_ski_.IsDefault()) { + _impl_.remote_ski_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.RegisterRemoteSkiRequest.remote_ski) +} + +// ------------------------------------------------------------------- + +// SubscribeUseCaseEventsRequest + +// .common_types.EntityAddress entity_address = 1; +inline bool SubscribeUseCaseEventsRequest::has_entity_address() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.entity_address_ != nullptr); + return value; +} +inline const ::common_types::EntityAddress& SubscribeUseCaseEventsRequest::_internal_entity_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::EntityAddress* p = _impl_.entity_address_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_EntityAddress_default_instance_); +} +inline const ::common_types::EntityAddress& SubscribeUseCaseEventsRequest::entity_address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SubscribeUseCaseEventsRequest.entity_address) + return _internal_entity_address(); +} +inline void SubscribeUseCaseEventsRequest::unsafe_arena_set_allocated_entity_address(::common_types::EntityAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entity_address_); + } + _impl_.entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.SubscribeUseCaseEventsRequest.entity_address) +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsRequest::release_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* released = _impl_.entity_address_; + _impl_.entity_address_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsRequest::unsafe_arena_release_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SubscribeUseCaseEventsRequest.entity_address) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* temp = _impl_.entity_address_; + _impl_.entity_address_ = nullptr; + return temp; +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsRequest::_internal_mutable_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.entity_address_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::EntityAddress>(GetArena()); + _impl_.entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(p); + } + return _impl_.entity_address_; +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsRequest::mutable_entity_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::EntityAddress* _msg = _internal_mutable_entity_address(); + // @@protoc_insertion_point(field_mutable:control_service.SubscribeUseCaseEventsRequest.entity_address) + return _msg; +} +inline void SubscribeUseCaseEventsRequest::set_allocated_entity_address(::common_types::EntityAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entity_address_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.SubscribeUseCaseEventsRequest.entity_address) +} + +// .control_service.UseCase use_case = 2; +inline bool SubscribeUseCaseEventsRequest::has_use_case() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.use_case_ != nullptr); + return value; +} +inline const ::control_service::UseCase& SubscribeUseCaseEventsRequest::_internal_use_case() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::control_service::UseCase* p = _impl_.use_case_; + return p != nullptr ? *p : reinterpret_cast(::control_service::_UseCase_default_instance_); +} +inline const ::control_service::UseCase& SubscribeUseCaseEventsRequest::use_case() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SubscribeUseCaseEventsRequest.use_case) + return _internal_use_case(); +} +inline void SubscribeUseCaseEventsRequest::unsafe_arena_set_allocated_use_case(::control_service::UseCase* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_); + } + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.SubscribeUseCaseEventsRequest.use_case) +} +inline ::control_service::UseCase* SubscribeUseCaseEventsRequest::release_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::control_service::UseCase* released = _impl_.use_case_; + _impl_.use_case_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::control_service::UseCase* SubscribeUseCaseEventsRequest::unsafe_arena_release_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SubscribeUseCaseEventsRequest.use_case) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::control_service::UseCase* temp = _impl_.use_case_; + _impl_.use_case_ = nullptr; + return temp; +} +inline ::control_service::UseCase* SubscribeUseCaseEventsRequest::_internal_mutable_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::control_service::UseCase>(GetArena()); + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(p); + } + return _impl_.use_case_; +} +inline ::control_service::UseCase* SubscribeUseCaseEventsRequest::mutable_use_case() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000002u; + ::control_service::UseCase* _msg = _internal_mutable_use_case(); + // @@protoc_insertion_point(field_mutable:control_service.SubscribeUseCaseEventsRequest.use_case) + return _msg; +} +inline void SubscribeUseCaseEventsRequest::set_allocated_use_case(::control_service::UseCase* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.SubscribeUseCaseEventsRequest.use_case) +} + +// ------------------------------------------------------------------- + +// SubscribeUseCaseEventsResponse + +// string remote_ski = 1; +inline void SubscribeUseCaseEventsResponse::clear_remote_ski() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.ClearToEmpty(); +} +inline const std::string& SubscribeUseCaseEventsResponse::remote_ski() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SubscribeUseCaseEventsResponse.remote_ski) + return _internal_remote_ski(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SubscribeUseCaseEventsResponse::set_remote_ski(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.SubscribeUseCaseEventsResponse.remote_ski) +} +inline std::string* SubscribeUseCaseEventsResponse::mutable_remote_ski() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_remote_ski(); + // @@protoc_insertion_point(field_mutable:control_service.SubscribeUseCaseEventsResponse.remote_ski) + return _s; +} +inline const std::string& SubscribeUseCaseEventsResponse::_internal_remote_ski() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.remote_ski_.Get(); +} +inline void SubscribeUseCaseEventsResponse::_internal_set_remote_ski(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.Set(value, GetArena()); +} +inline std::string* SubscribeUseCaseEventsResponse::_internal_mutable_remote_ski() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.remote_ski_.Mutable( GetArena()); +} +inline std::string* SubscribeUseCaseEventsResponse::release_remote_ski() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SubscribeUseCaseEventsResponse.remote_ski) + return _impl_.remote_ski_.Release(); +} +inline void SubscribeUseCaseEventsResponse::set_allocated_remote_ski(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.remote_ski_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.remote_ski_.IsDefault()) { + _impl_.remote_ski_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.SubscribeUseCaseEventsResponse.remote_ski) +} + +// .common_types.EntityAddress remote_entity_address = 2; +inline bool SubscribeUseCaseEventsResponse::has_remote_entity_address() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.remote_entity_address_ != nullptr); + return value; +} +inline const ::common_types::EntityAddress& SubscribeUseCaseEventsResponse::_internal_remote_entity_address() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::EntityAddress* p = _impl_.remote_entity_address_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_EntityAddress_default_instance_); +} +inline const ::common_types::EntityAddress& SubscribeUseCaseEventsResponse::remote_entity_address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SubscribeUseCaseEventsResponse.remote_entity_address) + return _internal_remote_entity_address(); +} +inline void SubscribeUseCaseEventsResponse::unsafe_arena_set_allocated_remote_entity_address(::common_types::EntityAddress* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.remote_entity_address_); + } + _impl_.remote_entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.SubscribeUseCaseEventsResponse.remote_entity_address) +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsResponse::release_remote_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* released = _impl_.remote_entity_address_; + _impl_.remote_entity_address_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsResponse::unsafe_arena_release_remote_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SubscribeUseCaseEventsResponse.remote_entity_address) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::EntityAddress* temp = _impl_.remote_entity_address_; + _impl_.remote_entity_address_ = nullptr; + return temp; +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsResponse::_internal_mutable_remote_entity_address() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.remote_entity_address_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::EntityAddress>(GetArena()); + _impl_.remote_entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(p); + } + return _impl_.remote_entity_address_; +} +inline ::common_types::EntityAddress* SubscribeUseCaseEventsResponse::mutable_remote_entity_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::EntityAddress* _msg = _internal_mutable_remote_entity_address(); + // @@protoc_insertion_point(field_mutable:control_service.SubscribeUseCaseEventsResponse.remote_entity_address) + return _msg; +} +inline void SubscribeUseCaseEventsResponse::set_allocated_remote_entity_address(::common_types::EntityAddress* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.remote_entity_address_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.remote_entity_address_ = reinterpret_cast<::common_types::EntityAddress*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.SubscribeUseCaseEventsResponse.remote_entity_address) +} + +// .control_service.UseCaseEvent use_case_event = 3; +inline bool SubscribeUseCaseEventsResponse::has_use_case_event() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.use_case_event_ != nullptr); + return value; +} +inline const ::control_service::UseCaseEvent& SubscribeUseCaseEventsResponse::_internal_use_case_event() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::control_service::UseCaseEvent* p = _impl_.use_case_event_; + return p != nullptr ? *p : reinterpret_cast(::control_service::_UseCaseEvent_default_instance_); +} +inline const ::control_service::UseCaseEvent& SubscribeUseCaseEventsResponse::use_case_event() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.SubscribeUseCaseEventsResponse.use_case_event) + return _internal_use_case_event(); +} +inline void SubscribeUseCaseEventsResponse::unsafe_arena_set_allocated_use_case_event(::control_service::UseCaseEvent* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_event_); + } + _impl_.use_case_event_ = reinterpret_cast<::control_service::UseCaseEvent*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.SubscribeUseCaseEventsResponse.use_case_event) +} +inline ::control_service::UseCaseEvent* SubscribeUseCaseEventsResponse::release_use_case_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::control_service::UseCaseEvent* released = _impl_.use_case_event_; + _impl_.use_case_event_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::control_service::UseCaseEvent* SubscribeUseCaseEventsResponse::unsafe_arena_release_use_case_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.SubscribeUseCaseEventsResponse.use_case_event) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::control_service::UseCaseEvent* temp = _impl_.use_case_event_; + _impl_.use_case_event_ = nullptr; + return temp; +} +inline ::control_service::UseCaseEvent* SubscribeUseCaseEventsResponse::_internal_mutable_use_case_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_event_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::control_service::UseCaseEvent>(GetArena()); + _impl_.use_case_event_ = reinterpret_cast<::control_service::UseCaseEvent*>(p); + } + return _impl_.use_case_event_; +} +inline ::control_service::UseCaseEvent* SubscribeUseCaseEventsResponse::mutable_use_case_event() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000002u; + ::control_service::UseCaseEvent* _msg = _internal_mutable_use_case_event(); + // @@protoc_insertion_point(field_mutable:control_service.SubscribeUseCaseEventsResponse.use_case_event) + return _msg; +} +inline void SubscribeUseCaseEventsResponse::set_allocated_use_case_event(::control_service::UseCaseEvent* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_event_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.use_case_event_ = reinterpret_cast<::control_service::UseCaseEvent*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.SubscribeUseCaseEventsResponse.use_case_event) +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +EmptyRequest CreateEmptyRequest(); + +EmptyResponse CreateEmptyResponse(); + +SetConfigRequest CreateSetConfigRequest( + uint32_t port, + std::string vendor_code, + std::string device_brand, + std::string device_model, + std::string serial_number, + std::vector device_categories, + control_service::DeviceType::Enum device_type, + std::vector entity_types, + uint32_t heartbeat_timeout_seconds); + +AddEntityRequest CreateAddEntityRequest( + control_service::EntityType::Enum type, + common_types::EntityAddress* address); + +RemoveEntityRequest CreateRemoveEntityRequest( + common_types::EntityAddress* address); + +AddUseCaseRequest CreateAddUseCaseRequest( + common_types::EntityAddress* entity_address, + control_service::UseCase* use_case); + +AddUseCaseResponse CreateAddUseCaseResponse( + std::string endpoint); + +RegisterRemoteSkiRequest CreateRegisterRemoteSkiRequest( + std::string remote_ski); + +SubscribeUseCaseEventsRequest CreateSubscribeUseCaseEventsRequest( + common_types::EntityAddress* entity_address, + control_service::UseCase* use_case); + +SubscribeUseCaseEventsResponse CreateSubscribeUseCaseEventsResponse( + std::string remote_ski, + common_types::EntityAddress* remote_entity_address, + control_service::UseCaseEvent* use_case_event); + +// @@protoc_insertion_point(namespace_scope) +} // namespace control_service + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // control_5fservice_2fmessages_2eproto_2epb_2eh diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.cc new file mode 100644 index 0000000000..a5b43a6876 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.cc @@ -0,0 +1,9 @@ +#include "control_service/types.grpc-ext.pb.h" + +#include +#include + +namespace control_service { + +} // namespace control_service + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.h new file mode 100644 index 0000000000..8ad299907f --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.h @@ -0,0 +1,10 @@ +#ifndef GENERATED_control_service_types_proto_EXT_H +#define GENERATED_control_service_types_proto_EXT_H + +#include "control_service/types.grpc.pb.h" + +namespace control_service { + +} // namespace control_service + +#endif // GENERATED_control_service_types_proto_EXT_H diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.cc new file mode 100644 index 0000000000..4fe8234343 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.cc @@ -0,0 +1,25 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: control_service/types.proto + +#include "control_service/types.pb.h" +#include "control_service/types.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace control_service { + +} // namespace control_service + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.h new file mode 100644 index 0000000000..046fba2153 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.h @@ -0,0 +1,39 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: control_service/types.proto +// Original file comments: +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +// +#ifndef GRPC_control_5fservice_2ftypes_2eproto__INCLUDED +#define GRPC_control_5fservice_2ftypes_2eproto__INCLUDED + +#include "control_service/types.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace control_service { + +} // namespace control_service + + +#include +#endif // GRPC_control_5fservice_2ftypes_2eproto__INCLUDED diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.cc new file mode 100644 index 0000000000..3c4b7ad6fb --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.cc @@ -0,0 +1,1694 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: control_service/types.proto +// Protobuf C++ Version: 5.29.0 + +#include "control_service/types.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace control_service { + template +PROTOBUF_CONSTEXPR UseCase_NameType::UseCase_NameType(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct UseCase_NameTypeDefaultTypeInternal { + PROTOBUF_CONSTEXPR UseCase_NameTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UseCase_NameTypeDefaultTypeInternal() {} + union { + UseCase_NameType _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseCase_NameTypeDefaultTypeInternal _UseCase_NameType_default_instance_; + template +PROTOBUF_CONSTEXPR UseCase_ActorType::UseCase_ActorType(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct UseCase_ActorTypeDefaultTypeInternal { + PROTOBUF_CONSTEXPR UseCase_ActorTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UseCase_ActorTypeDefaultTypeInternal() {} + union { + UseCase_ActorType _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseCase_ActorTypeDefaultTypeInternal _UseCase_ActorType_default_instance_; + +inline constexpr UseCase::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : actor_{static_cast< ::control_service::UseCase_ActorType_Enum >(0)}, + name_{static_cast< ::control_service::UseCase_NameType_Enum >(0)}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR UseCase::UseCase(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct UseCaseDefaultTypeInternal { + PROTOBUF_CONSTEXPR UseCaseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UseCaseDefaultTypeInternal() {} + union { + UseCase _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseCaseDefaultTypeInternal _UseCase_default_instance_; + template +PROTOBUF_CONSTEXPR EntityType::EntityType(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct EntityTypeDefaultTypeInternal { + PROTOBUF_CONSTEXPR EntityTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EntityTypeDefaultTypeInternal() {} + union { + EntityType _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EntityTypeDefaultTypeInternal _EntityType_default_instance_; + template +PROTOBUF_CONSTEXPR DeviceType::DeviceType(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct DeviceTypeDefaultTypeInternal { + PROTOBUF_CONSTEXPR DeviceTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~DeviceTypeDefaultTypeInternal() {} + union { + DeviceType _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceTypeDefaultTypeInternal _DeviceType_default_instance_; + template +PROTOBUF_CONSTEXPR DeviceCategory::DeviceCategory(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct DeviceCategoryDefaultTypeInternal { + PROTOBUF_CONSTEXPR DeviceCategoryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~DeviceCategoryDefaultTypeInternal() {} + union { + DeviceCategory _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceCategoryDefaultTypeInternal _DeviceCategory_default_instance_; + +inline constexpr UseCaseEvent::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + event_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + use_case_{nullptr} {} + +template +PROTOBUF_CONSTEXPR UseCaseEvent::UseCaseEvent(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct UseCaseEventDefaultTypeInternal { + PROTOBUF_CONSTEXPR UseCaseEventDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UseCaseEventDefaultTypeInternal() {} + union { + UseCaseEvent _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseCaseEventDefaultTypeInternal _UseCaseEvent_default_instance_; +} // namespace control_service +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_control_5fservice_2ftypes_2eproto[6]; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_control_5fservice_2ftypes_2eproto = nullptr; +const ::uint32_t + TableStruct_control_5fservice_2ftypes_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::control_service::DeviceCategory, _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(::control_service::EntityType, _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(::control_service::DeviceType, _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(::control_service::UseCase_ActorType, _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(::control_service::UseCase_NameType, _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(::control_service::UseCase, _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(::control_service::UseCase, _impl_.actor_), + PROTOBUF_FIELD_OFFSET(::control_service::UseCase, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::control_service::UseCaseEvent, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::control_service::UseCaseEvent, _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(::control_service::UseCaseEvent, _impl_.use_case_), + PROTOBUF_FIELD_OFFSET(::control_service::UseCaseEvent, _impl_.event_), + 0, + ~0u, +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::control_service::DeviceCategory)}, + {8, -1, -1, sizeof(::control_service::EntityType)}, + {16, -1, -1, sizeof(::control_service::DeviceType)}, + {24, -1, -1, sizeof(::control_service::UseCase_ActorType)}, + {32, -1, -1, sizeof(::control_service::UseCase_NameType)}, + {40, -1, -1, sizeof(::control_service::UseCase)}, + {50, 60, -1, sizeof(::control_service::UseCaseEvent)}, +}; +static const ::_pb::Message* const file_default_instances[] = { + &::control_service::_DeviceCategory_default_instance_._instance, + &::control_service::_EntityType_default_instance_._instance, + &::control_service::_DeviceType_default_instance_._instance, + &::control_service::_UseCase_ActorType_default_instance_._instance, + &::control_service::_UseCase_NameType_default_instance_._instance, + &::control_service::_UseCase_default_instance_._instance, + &::control_service::_UseCaseEvent_default_instance_._instance, +}; +const char descriptor_table_protodef_control_5fservice_2ftypes_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\033control_service/types.proto\022\017control_s" + "ervice\"\253\001\n\016DeviceCategory\"\230\001\n\004Enum\022\013\n\007UN" + "KNOWN\020\000\022\027\n\023GRID_CONNECTION_HUB\020\001\022\034\n\030ENER" + "GY_MANAGEMENT_SYSTEM\020\002\022\016\n\nE_MOBILITY\020\003\022\010" + "\n\004HVAC\020\004\022\014\n\010INVERTER\020\005\022\026\n\022DOMESTIC_APPLI" + "ANCE\020\006\022\014\n\010METERING\020\007\"\262\007\n\nEntityType\"\243\007\n\004" + "Enum\022\013\n\007UNKNOWN\020\000\022\013\n\007Battery\020\001\022\016\n\nCompre" + "ssor\020\002\022\025\n\021DeviceInformation\020\003\022\016\n\nDHWCirc" + "uit\020\004\022\016\n\nDHWStorage\020\005\022\016\n\nDishwasher\020\006\022\t\n" + "\005Dryer\020\007\022\035\n\031ElectricalImmersionHeater\020\010\022" + "\007\n\003Fan\020\t\022\027\n\023GasHeatingAppliance\020\n\022\013\n\007Gen" + "eric\020\013\022\030\n\024HeatingBufferStorage\020\014\022\022\n\016Heat" + "ingCircuit\020\r\022\021\n\rHeatingObject\020\016\022\017\n\013Heati" + "ngZone\020\017\022\025\n\021HeatPumpAppliance\020\020\022\023\n\017HeatS" + "inkCircuit\020\021\022\025\n\021HeatSourceCircuit\020\022\022\022\n\016H" + "eatSourceUnit\020\023\022\022\n\016HvacController\020\024\022\014\n\010H" + "vacRoom\020\025\022\024\n\020InstantDHWHeater\020\026\022\014\n\010Inver" + "ter\020\027\022\027\n\023OilHeatingAppliance\020\030\022\010\n\004Pump\020\031" + "\022\026\n\022RefrigerantCircuit\020\032\022\030\n\024SmartEnergyA" + "ppliance\020\033\022\023\n\017SolarDHWStorage\020\034\022\027\n\023Solar" + "ThermalCircuit\020\035\022\027\n\023SubMeterElectricity\020" + "\036\022\025\n\021TemperatureSensor\020\037\022\n\n\006Washer\020 \022\021\n\r" + "BatterySystem\020!\022\037\n\033ElectricityGeneration" + "System\020\"\022\034\n\030ElectricityStorageSystem\020#\022!" + "\n\035GridConnectionPointOfPremises\020$\022\r\n\tHou" + "sehold\020%\022\014\n\010PVSystem\020&\022\006\n\002EV\020\'\022\010\n\004EVSE\020(" + "\022\022\n\016ChargingOutlet\020)\022\007\n\003CEM\020*\022\006\n\002PV\020+\022\016\n" + "\nPVESHybrid\020,\022\025\n\021ElectricalStorage\020-\022\014\n\010" + "PVString\020.\022\r\n\tGridGuard\020/\022\026\n\022Controllabl" + "eSystem\0200\"\275\002\n\nDeviceType\"\256\002\n\004Enum\022\013\n\007UNK" + "NOWN\020\000\022\016\n\nDISHWASHER\020\001\022\t\n\005DRYER\020\002\022\026\n\022ENV" + "IRONMENT_SENSOR\020\003\022\013\n\007GENERIC\020\004\022\032\n\026HEAT_G" + "ENERATION_SYSTEM\020\005\022\024\n\020HEAT_SINK_SYSTEM\020\006" + "\022\027\n\023HEAT_STORAGE_SYSTEM\020\007\022\023\n\017HVAC_CONTRO" + "LLER\020\010\022\014\n\010SUBMETER\020\t\022\n\n\006WASHER\020\n\022\035\n\031ELEC" + "TRICITY_SUPPLY_SYSTEM\020\013\022\034\n\030ENERGY_MANAGE" + "MENT_SYSTEM\020\014\022\014\n\010INVERTER\020\r\022\024\n\020CHARGING_" + "STATION\020\016\"\312\017\n\007UseCase\0226\n\005actor\030\001 \001(\0162\'.c" + "ontrol_service.UseCase.ActorType.Enum\0224\n" + "\004name\030\002 \001(\0162&.control_service.UseCase.Na" + "meType.Enum\032\345\003\n\tActorType\"\327\003\n\004Enum\022\013\n\007UN" + "KNOWN\020\000\022\013\n\007Battery\020\001\022\021\n\rBatterySystem\020\002\022" + "\007\n\003CEM\020\003\022\032\n\026ConfigurationAppliance\020\004\022\016\n\n" + "Compressor\020\005\022\026\n\022ControllableSystem\020\006\022\016\n\n" + "DHWCircuit\020\007\022\020\n\014EnergyBroker\020\010\022\022\n\016Energy" + "Consumer\020\t\022\017\n\013EnergyGuard\020\n\022\010\n\004EVSE\020\013\022\006\n" + "\002EV\020\014\022\027\n\023GridConnectionPoint\020\r\022\014\n\010HeatPu" + "mp\020\016\022\022\n\016HeatingCircuit\020\017\022\017\n\013HeatingZone\020" + "\020\022\014\n\010HVACRoom\020\021\022\014\n\010Inverter\020\022\022\021\n\rMonitor" + "edUnit\020\023\022\027\n\023MonitoringAppliance\020\024\022\034\n\030Out" + "doorTemperatureSensor\020\025\022\014\n\010PVString\020\026\022\014\n" + "\010PVSystem\020\027\022\022\n\016SmartAppliance\020\030\022\032\n\026Visua" + "lizationAppliance\020\031\032\350\n\n\010NameType\"\333\n\n\004Enu" + "m\022\013\n\007UNKNOWN\020\000\022$\n configurationOfDhwSyst" + "emFunction\020\001\022!\n\035configurationOfDhwTemper" + "ature\020\002\022,\n(configurationOfRoomCoolingSys" + "temFunction\020\003\022)\n%configurationOfRoomCool" + "ingTemperature\020\004\022,\n(configurationOfRoomH" + "eatingSystemFunction\020\005\022)\n%configurationO" + "fRoomHeatingTemperature\020\006\022\024\n\020controlOfBa" + "ttery\020\007\022\031\n\025coordinatedEvCharging\020\010\022\025\n\021ev" + "ChargingSummary\020\t\022#\n\037evCommissioningAndC" + "onfiguration\020\n\022%\n!evseCommissioningAndCo" + "nfiguration\020\013\022\023\n\017evStateOfCharge\020\014\022\020\n\014fl" + "exibleLoad\020\r\022\036\n\032flexibleStartForWhiteGoo" + "ds\020\016\022 \n\034limitationOfPowerConsumption\020\017\022\037" + "\n\033limitationOfPowerProduction\020\020\0221\n-incen" + "tiveTableBasedPowerConsumptionManagement" + "\020\021\022,\n(measurementOfElectricityDuringEvCh" + "arging\020\022\0222\n.monitoringAndControlOfSmartG" + "ridReadyConditions\020\023\022\027\n\023monitoringOfBatt" + "ery\020\024\022!\n\035monitoringOfDhwSystemFunction\020\025" + "\022\036\n\032monitoringOfDhwTemperature\020\026\022#\n\037moni" + "toringOfGridConnectionPoint\020\027\022\030\n\024monitor" + "ingOfInverter\020\030\022\"\n\036monitoringOfOutdoorTe" + "mperature\020\031\022 \n\034monitoringOfPowerConsumpt" + "ion\020\032\022\030\n\024monitoringOfPvString\020\033\022)\n%monit" + "oringOfRoomCoolingSystemFunction\020\034\022)\n%mo" + "nitoringOfRoomHeatingSystemFunction\020\035\022\037\n" + "\033monitoringOfRoomTemperature\020\036\022@\n= 1900 && _MSC_VER < 1912)) + +constexpr DeviceCategory_Enum DeviceCategory::UNKNOWN; +constexpr DeviceCategory_Enum DeviceCategory::GRID_CONNECTION_HUB; +constexpr DeviceCategory_Enum DeviceCategory::ENERGY_MANAGEMENT_SYSTEM; +constexpr DeviceCategory_Enum DeviceCategory::E_MOBILITY; +constexpr DeviceCategory_Enum DeviceCategory::HVAC; +constexpr DeviceCategory_Enum DeviceCategory::INVERTER; +constexpr DeviceCategory_Enum DeviceCategory::DOMESTIC_APPLIANCE; +constexpr DeviceCategory_Enum DeviceCategory::METERING; +constexpr DeviceCategory_Enum DeviceCategory::Enum_MIN; +constexpr DeviceCategory_Enum DeviceCategory::Enum_MAX; +constexpr int DeviceCategory::Enum_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::google::protobuf::EnumDescriptor* EntityType_Enum_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_control_5fservice_2ftypes_2eproto); + return file_level_enum_descriptors_control_5fservice_2ftypes_2eproto[1]; +} +PROTOBUF_CONSTINIT const uint32_t EntityType_Enum_internal_data_[] = { + 3211264u, 0u, }; +bool EntityType_Enum_IsValid(int value) { + return 0 <= value && value <= 48; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr EntityType_Enum EntityType::UNKNOWN; +constexpr EntityType_Enum EntityType::Battery; +constexpr EntityType_Enum EntityType::Compressor; +constexpr EntityType_Enum EntityType::DeviceInformation; +constexpr EntityType_Enum EntityType::DHWCircuit; +constexpr EntityType_Enum EntityType::DHWStorage; +constexpr EntityType_Enum EntityType::Dishwasher; +constexpr EntityType_Enum EntityType::Dryer; +constexpr EntityType_Enum EntityType::ElectricalImmersionHeater; +constexpr EntityType_Enum EntityType::Fan; +constexpr EntityType_Enum EntityType::GasHeatingAppliance; +constexpr EntityType_Enum EntityType::Generic; +constexpr EntityType_Enum EntityType::HeatingBufferStorage; +constexpr EntityType_Enum EntityType::HeatingCircuit; +constexpr EntityType_Enum EntityType::HeatingObject; +constexpr EntityType_Enum EntityType::HeatingZone; +constexpr EntityType_Enum EntityType::HeatPumpAppliance; +constexpr EntityType_Enum EntityType::HeatSinkCircuit; +constexpr EntityType_Enum EntityType::HeatSourceCircuit; +constexpr EntityType_Enum EntityType::HeatSourceUnit; +constexpr EntityType_Enum EntityType::HvacController; +constexpr EntityType_Enum EntityType::HvacRoom; +constexpr EntityType_Enum EntityType::InstantDHWHeater; +constexpr EntityType_Enum EntityType::Inverter; +constexpr EntityType_Enum EntityType::OilHeatingAppliance; +constexpr EntityType_Enum EntityType::Pump; +constexpr EntityType_Enum EntityType::RefrigerantCircuit; +constexpr EntityType_Enum EntityType::SmartEnergyAppliance; +constexpr EntityType_Enum EntityType::SolarDHWStorage; +constexpr EntityType_Enum EntityType::SolarThermalCircuit; +constexpr EntityType_Enum EntityType::SubMeterElectricity; +constexpr EntityType_Enum EntityType::TemperatureSensor; +constexpr EntityType_Enum EntityType::Washer; +constexpr EntityType_Enum EntityType::BatterySystem; +constexpr EntityType_Enum EntityType::ElectricityGenerationSystem; +constexpr EntityType_Enum EntityType::ElectricityStorageSystem; +constexpr EntityType_Enum EntityType::GridConnectionPointOfPremises; +constexpr EntityType_Enum EntityType::Household; +constexpr EntityType_Enum EntityType::PVSystem; +constexpr EntityType_Enum EntityType::EV; +constexpr EntityType_Enum EntityType::EVSE; +constexpr EntityType_Enum EntityType::ChargingOutlet; +constexpr EntityType_Enum EntityType::CEM; +constexpr EntityType_Enum EntityType::PV; +constexpr EntityType_Enum EntityType::PVESHybrid; +constexpr EntityType_Enum EntityType::ElectricalStorage; +constexpr EntityType_Enum EntityType::PVString; +constexpr EntityType_Enum EntityType::GridGuard; +constexpr EntityType_Enum EntityType::ControllableSystem; +constexpr EntityType_Enum EntityType::Enum_MIN; +constexpr EntityType_Enum EntityType::Enum_MAX; +constexpr int EntityType::Enum_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::google::protobuf::EnumDescriptor* DeviceType_Enum_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_control_5fservice_2ftypes_2eproto); + return file_level_enum_descriptors_control_5fservice_2ftypes_2eproto[2]; +} +PROTOBUF_CONSTINIT const uint32_t DeviceType_Enum_internal_data_[] = { + 983040u, 0u, }; +bool DeviceType_Enum_IsValid(int value) { + return 0 <= value && value <= 14; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr DeviceType_Enum DeviceType::UNKNOWN; +constexpr DeviceType_Enum DeviceType::DISHWASHER; +constexpr DeviceType_Enum DeviceType::DRYER; +constexpr DeviceType_Enum DeviceType::ENVIRONMENT_SENSOR; +constexpr DeviceType_Enum DeviceType::GENERIC; +constexpr DeviceType_Enum DeviceType::HEAT_GENERATION_SYSTEM; +constexpr DeviceType_Enum DeviceType::HEAT_SINK_SYSTEM; +constexpr DeviceType_Enum DeviceType::HEAT_STORAGE_SYSTEM; +constexpr DeviceType_Enum DeviceType::HVAC_CONTROLLER; +constexpr DeviceType_Enum DeviceType::SUBMETER; +constexpr DeviceType_Enum DeviceType::WASHER; +constexpr DeviceType_Enum DeviceType::ELECTRICITY_SUPPLY_SYSTEM; +constexpr DeviceType_Enum DeviceType::ENERGY_MANAGEMENT_SYSTEM; +constexpr DeviceType_Enum DeviceType::INVERTER; +constexpr DeviceType_Enum DeviceType::CHARGING_STATION; +constexpr DeviceType_Enum DeviceType::Enum_MIN; +constexpr DeviceType_Enum DeviceType::Enum_MAX; +constexpr int DeviceType::Enum_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::google::protobuf::EnumDescriptor* UseCase_ActorType_Enum_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_control_5fservice_2ftypes_2eproto); + return file_level_enum_descriptors_control_5fservice_2ftypes_2eproto[3]; +} +PROTOBUF_CONSTINIT const uint32_t UseCase_ActorType_Enum_internal_data_[] = { + 1703936u, 0u, }; +bool UseCase_ActorType_Enum_IsValid(int value) { + return 0 <= value && value <= 25; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr UseCase_ActorType_Enum UseCase_ActorType::UNKNOWN; +constexpr UseCase_ActorType_Enum UseCase_ActorType::Battery; +constexpr UseCase_ActorType_Enum UseCase_ActorType::BatterySystem; +constexpr UseCase_ActorType_Enum UseCase_ActorType::CEM; +constexpr UseCase_ActorType_Enum UseCase_ActorType::ConfigurationAppliance; +constexpr UseCase_ActorType_Enum UseCase_ActorType::Compressor; +constexpr UseCase_ActorType_Enum UseCase_ActorType::ControllableSystem; +constexpr UseCase_ActorType_Enum UseCase_ActorType::DHWCircuit; +constexpr UseCase_ActorType_Enum UseCase_ActorType::EnergyBroker; +constexpr UseCase_ActorType_Enum UseCase_ActorType::EnergyConsumer; +constexpr UseCase_ActorType_Enum UseCase_ActorType::EnergyGuard; +constexpr UseCase_ActorType_Enum UseCase_ActorType::EVSE; +constexpr UseCase_ActorType_Enum UseCase_ActorType::EV; +constexpr UseCase_ActorType_Enum UseCase_ActorType::GridConnectionPoint; +constexpr UseCase_ActorType_Enum UseCase_ActorType::HeatPump; +constexpr UseCase_ActorType_Enum UseCase_ActorType::HeatingCircuit; +constexpr UseCase_ActorType_Enum UseCase_ActorType::HeatingZone; +constexpr UseCase_ActorType_Enum UseCase_ActorType::HVACRoom; +constexpr UseCase_ActorType_Enum UseCase_ActorType::Inverter; +constexpr UseCase_ActorType_Enum UseCase_ActorType::MonitoredUnit; +constexpr UseCase_ActorType_Enum UseCase_ActorType::MonitoringAppliance; +constexpr UseCase_ActorType_Enum UseCase_ActorType::OutdoorTemperatureSensor; +constexpr UseCase_ActorType_Enum UseCase_ActorType::PVString; +constexpr UseCase_ActorType_Enum UseCase_ActorType::PVSystem; +constexpr UseCase_ActorType_Enum UseCase_ActorType::SmartAppliance; +constexpr UseCase_ActorType_Enum UseCase_ActorType::VisualizationAppliance; +constexpr UseCase_ActorType_Enum UseCase_ActorType::Enum_MIN; +constexpr UseCase_ActorType_Enum UseCase_ActorType::Enum_MAX; +constexpr int UseCase_ActorType::Enum_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::google::protobuf::EnumDescriptor* UseCase_NameType_Enum_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_control_5fservice_2ftypes_2eproto); + return file_level_enum_descriptors_control_5fservice_2ftypes_2eproto[4]; +} +PROTOBUF_CONSTINIT const uint32_t UseCase_NameType_Enum_internal_data_[] = { + 2424832u, 0u, }; +bool UseCase_NameType_Enum_IsValid(int value) { + return 0 <= value && value <= 36; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr UseCase_NameType_Enum UseCase_NameType::UNKNOWN; +constexpr UseCase_NameType_Enum UseCase_NameType::configurationOfDhwSystemFunction; +constexpr UseCase_NameType_Enum UseCase_NameType::configurationOfDhwTemperature; +constexpr UseCase_NameType_Enum UseCase_NameType::configurationOfRoomCoolingSystemFunction; +constexpr UseCase_NameType_Enum UseCase_NameType::configurationOfRoomCoolingTemperature; +constexpr UseCase_NameType_Enum UseCase_NameType::configurationOfRoomHeatingSystemFunction; +constexpr UseCase_NameType_Enum UseCase_NameType::configurationOfRoomHeatingTemperature; +constexpr UseCase_NameType_Enum UseCase_NameType::controlOfBattery; +constexpr UseCase_NameType_Enum UseCase_NameType::coordinatedEvCharging; +constexpr UseCase_NameType_Enum UseCase_NameType::evChargingSummary; +constexpr UseCase_NameType_Enum UseCase_NameType::evCommissioningAndConfiguration; +constexpr UseCase_NameType_Enum UseCase_NameType::evseCommissioningAndConfiguration; +constexpr UseCase_NameType_Enum UseCase_NameType::evStateOfCharge; +constexpr UseCase_NameType_Enum UseCase_NameType::flexibleLoad; +constexpr UseCase_NameType_Enum UseCase_NameType::flexibleStartForWhiteGoods; +constexpr UseCase_NameType_Enum UseCase_NameType::limitationOfPowerConsumption; +constexpr UseCase_NameType_Enum UseCase_NameType::limitationOfPowerProduction; +constexpr UseCase_NameType_Enum UseCase_NameType::incentiveTableBasedPowerConsumptionManagement; +constexpr UseCase_NameType_Enum UseCase_NameType::measurementOfElectricityDuringEvCharging; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringAndControlOfSmartGridReadyConditions; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfBattery; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfDhwSystemFunction; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfDhwTemperature; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfGridConnectionPoint; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfInverter; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfOutdoorTemperature; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfPowerConsumption; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfPvString; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfRoomCoolingSystemFunction; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfRoomHeatingSystemFunction; +constexpr UseCase_NameType_Enum UseCase_NameType::monitoringOfRoomTemperature; +constexpr UseCase_NameType_Enum UseCase_NameType::optimizationOfSelfConsumptionByHeatPumpCompressorFlexibility; +constexpr UseCase_NameType_Enum UseCase_NameType::optimizationOfSelfConsumptionDuringEvCharging; +constexpr UseCase_NameType_Enum UseCase_NameType::overloadProtectionByEvChargingCurrentCurtailment; +constexpr UseCase_NameType_Enum UseCase_NameType::visualizationOfAggregatedBatteryData; +constexpr UseCase_NameType_Enum UseCase_NameType::visualizationOfAggregatedPhotovoltaicData; +constexpr UseCase_NameType_Enum UseCase_NameType::visualizationOfHeatingAreaName; +constexpr UseCase_NameType_Enum UseCase_NameType::Enum_MIN; +constexpr UseCase_NameType_Enum UseCase_NameType::Enum_MAX; +constexpr int UseCase_NameType::Enum_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::google::protobuf::EnumDescriptor* SharedType_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_control_5fservice_2ftypes_2eproto); + return file_level_enum_descriptors_control_5fservice_2ftypes_2eproto[5]; +} +PROTOBUF_CONSTINIT const uint32_t SharedType_internal_data_[] = { + 65536u, 0u, }; +bool SharedType_IsValid(int value) { + return 0 <= value && value <= 0; +} +// =================================================================== + +class DeviceCategory::_Internal { + public: +}; + +DeviceCategory::DeviceCategory(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.DeviceCategory) +} +DeviceCategory::DeviceCategory( + ::google::protobuf::Arena* arena, + const DeviceCategory& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + DeviceCategory* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.DeviceCategory) +} + +inline void* DeviceCategory::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) DeviceCategory(arena); +} +constexpr auto DeviceCategory::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DeviceCategory), + alignof(DeviceCategory)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull DeviceCategory::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_DeviceCategory_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DeviceCategory::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DeviceCategory::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &DeviceCategory::ByteSizeLong, + &DeviceCategory::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DeviceCategory, _impl_._cached_size_), + false, + }, + &DeviceCategory::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* DeviceCategory::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> DeviceCategory::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::DeviceCategory>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata DeviceCategory::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class EntityType::_Internal { + public: +}; + +EntityType::EntityType(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.EntityType) +} +EntityType::EntityType( + ::google::protobuf::Arena* arena, + const EntityType& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + EntityType* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.EntityType) +} + +inline void* EntityType::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) EntityType(arena); +} +constexpr auto EntityType::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(EntityType), + alignof(EntityType)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull EntityType::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_EntityType_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &EntityType::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &EntityType::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &EntityType::ByteSizeLong, + &EntityType::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(EntityType, _impl_._cached_size_), + false, + }, + &EntityType::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* EntityType::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> EntityType::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::EntityType>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata EntityType::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class DeviceType::_Internal { + public: +}; + +DeviceType::DeviceType(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.DeviceType) +} +DeviceType::DeviceType( + ::google::protobuf::Arena* arena, + const DeviceType& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + DeviceType* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.DeviceType) +} + +inline void* DeviceType::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) DeviceType(arena); +} +constexpr auto DeviceType::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DeviceType), + alignof(DeviceType)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull DeviceType::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_DeviceType_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DeviceType::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DeviceType::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &DeviceType::ByteSizeLong, + &DeviceType::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DeviceType, _impl_._cached_size_), + false, + }, + &DeviceType::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* DeviceType::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> DeviceType::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::DeviceType>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata DeviceType::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class UseCase_ActorType::_Internal { + public: +}; + +UseCase_ActorType::UseCase_ActorType(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.UseCase.ActorType) +} +UseCase_ActorType::UseCase_ActorType( + ::google::protobuf::Arena* arena, + const UseCase_ActorType& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + UseCase_ActorType* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.UseCase.ActorType) +} + +inline void* UseCase_ActorType::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UseCase_ActorType(arena); +} +constexpr auto UseCase_ActorType::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseCase_ActorType), + alignof(UseCase_ActorType)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull UseCase_ActorType::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_UseCase_ActorType_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UseCase_ActorType::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UseCase_ActorType::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &UseCase_ActorType::ByteSizeLong, + &UseCase_ActorType::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UseCase_ActorType, _impl_._cached_size_), + false, + }, + &UseCase_ActorType::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* UseCase_ActorType::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> UseCase_ActorType::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::UseCase_ActorType>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata UseCase_ActorType::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class UseCase_NameType::_Internal { + public: +}; + +UseCase_NameType::UseCase_NameType(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:control_service.UseCase.NameType) +} +UseCase_NameType::UseCase_NameType( + ::google::protobuf::Arena* arena, + const UseCase_NameType& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + UseCase_NameType* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:control_service.UseCase.NameType) +} + +inline void* UseCase_NameType::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UseCase_NameType(arena); +} +constexpr auto UseCase_NameType::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseCase_NameType), + alignof(UseCase_NameType)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull UseCase_NameType::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_UseCase_NameType_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UseCase_NameType::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UseCase_NameType::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &UseCase_NameType::ByteSizeLong, + &UseCase_NameType::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UseCase_NameType, _impl_._cached_size_), + false, + }, + &UseCase_NameType::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* UseCase_NameType::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> UseCase_NameType::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::UseCase_NameType>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata UseCase_NameType::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class UseCase::_Internal { + public: +}; + +UseCase::UseCase(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.UseCase) +} +UseCase::UseCase( + ::google::protobuf::Arena* arena, const UseCase& from) + : UseCase(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE UseCase::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void UseCase::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, actor_), + 0, + offsetof(Impl_, name_) - + offsetof(Impl_, actor_) + + sizeof(Impl_::name_)); +} +UseCase::~UseCase() { + // @@protoc_insertion_point(destructor:control_service.UseCase) + SharedDtor(*this); +} +inline void UseCase::SharedDtor(MessageLite& self) { + UseCase& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* UseCase::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UseCase(arena); +} +constexpr auto UseCase::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseCase), + alignof(UseCase)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull UseCase::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_UseCase_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UseCase::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UseCase::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &UseCase::ByteSizeLong, + &UseCase::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UseCase, _impl_._cached_size_), + false, + }, + &UseCase::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* UseCase::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> UseCase::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::UseCase>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .control_service.UseCase.NameType.Enum name = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(UseCase, _impl_.name_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(UseCase, _impl_.name_)}}, + // .control_service.UseCase.ActorType.Enum actor = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(UseCase, _impl_.actor_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(UseCase, _impl_.actor_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .control_service.UseCase.ActorType.Enum actor = 1; + {PROTOBUF_FIELD_OFFSET(UseCase, _impl_.actor_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, + // .control_service.UseCase.NameType.Enum name = 2; + {PROTOBUF_FIELD_OFFSET(UseCase, _impl_.name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void UseCase::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.UseCase) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.actor_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.name_) - + reinterpret_cast(&_impl_.actor_)) + sizeof(_impl_.name_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* UseCase::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const UseCase& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* UseCase::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const UseCase& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.UseCase) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // .control_service.UseCase.ActorType.Enum actor = 1; + if (this_._internal_actor() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this_._internal_actor(), target); + } + + // .control_service.UseCase.NameType.Enum name = 2; + if (this_._internal_name() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.UseCase) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t UseCase::ByteSizeLong(const MessageLite& base) { + const UseCase& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t UseCase::ByteSizeLong() const { + const UseCase& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.UseCase) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // .control_service.UseCase.ActorType.Enum actor = 1; + if (this_._internal_actor() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_actor()); + } + // .control_service.UseCase.NameType.Enum name = 2; + if (this_._internal_name() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_name()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void UseCase::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.UseCase) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_actor() != 0) { + _this->_impl_.actor_ = from._impl_.actor_; + } + if (from._internal_name() != 0) { + _this->_impl_.name_ = from._impl_.name_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void UseCase::CopyFrom(const UseCase& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.UseCase) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void UseCase::InternalSwap(UseCase* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(UseCase, _impl_.name_) + + sizeof(UseCase::_impl_.name_) + - PROTOBUF_FIELD_OFFSET(UseCase, _impl_.actor_)>( + reinterpret_cast(&_impl_.actor_), + reinterpret_cast(&other->_impl_.actor_)); +} + +::google::protobuf::Metadata UseCase::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class UseCaseEvent::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(UseCaseEvent, _impl_._has_bits_); +}; + +UseCaseEvent::UseCaseEvent(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:control_service.UseCaseEvent) +} +inline PROTOBUF_NDEBUG_INLINE UseCaseEvent::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::control_service::UseCaseEvent& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + event_(arena, from.event_) {} + +UseCaseEvent::UseCaseEvent( + ::google::protobuf::Arena* arena, + const UseCaseEvent& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + UseCaseEvent* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.use_case_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::control_service::UseCase>( + arena, *from._impl_.use_case_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:control_service.UseCaseEvent) +} +inline PROTOBUF_NDEBUG_INLINE UseCaseEvent::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + event_(arena) {} + +inline void UseCaseEvent::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.use_case_ = {}; +} +UseCaseEvent::~UseCaseEvent() { + // @@protoc_insertion_point(destructor:control_service.UseCaseEvent) + SharedDtor(*this); +} +inline void UseCaseEvent::SharedDtor(MessageLite& self) { + UseCaseEvent& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.event_.Destroy(); + delete this_._impl_.use_case_; + this_._impl_.~Impl_(); +} + +inline void* UseCaseEvent::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UseCaseEvent(arena); +} +constexpr auto UseCaseEvent::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(UseCaseEvent), + alignof(UseCaseEvent)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull UseCaseEvent::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_UseCaseEvent_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UseCaseEvent::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UseCaseEvent::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &UseCaseEvent::ByteSizeLong, + &UseCaseEvent::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UseCaseEvent, _impl_._cached_size_), + false, + }, + &UseCaseEvent::kDescriptorMethods, + &descriptor_table_control_5fservice_2ftypes_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* UseCaseEvent::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 42, 2> UseCaseEvent::_table_ = { + { + PROTOBUF_FIELD_OFFSET(UseCaseEvent, _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), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::control_service::UseCaseEvent>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string event = 2; + {::_pbi::TcParser::FastUS1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(UseCaseEvent, _impl_.event_)}}, + // .control_service.UseCase use_case = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(UseCaseEvent, _impl_.use_case_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .control_service.UseCase use_case = 1; + {PROTOBUF_FIELD_OFFSET(UseCaseEvent, _impl_.use_case_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string event = 2; + {PROTOBUF_FIELD_OFFSET(UseCaseEvent, _impl_.event_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, {{ + {::_pbi::TcParser::GetTable<::control_service::UseCase>()}, + }}, {{ + "\34\0\5\0\0\0\0\0" + "control_service.UseCaseEvent" + "event" + }}, +}; + +PROTOBUF_NOINLINE void UseCaseEvent::Clear() { +// @@protoc_insertion_point(message_clear_start:control_service.UseCaseEvent) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.event_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.use_case_ != nullptr); + _impl_.use_case_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* UseCaseEvent::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const UseCaseEvent& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* UseCaseEvent::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const UseCaseEvent& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:control_service.UseCaseEvent) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .control_service.UseCase use_case = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.use_case_, this_._impl_.use_case_->GetCachedSize(), target, + stream); + } + + // string event = 2; + if (!this_._internal_event().empty()) { + const std::string& _s = this_._internal_event(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "control_service.UseCaseEvent.event"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:control_service.UseCaseEvent) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t UseCaseEvent::ByteSizeLong(const MessageLite& base) { + const UseCaseEvent& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t UseCaseEvent::ByteSizeLong() const { + const UseCaseEvent& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:control_service.UseCaseEvent) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string event = 2; + if (!this_._internal_event().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_event()); + } + } + { + // .control_service.UseCase use_case = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.use_case_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void UseCaseEvent::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:control_service.UseCaseEvent) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_event().empty()) { + _this->_internal_set_event(from._internal_event()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.use_case_ != nullptr); + if (_this->_impl_.use_case_ == nullptr) { + _this->_impl_.use_case_ = + ::google::protobuf::Message::CopyConstruct<::control_service::UseCase>(arena, *from._impl_.use_case_); + } else { + _this->_impl_.use_case_->MergeFrom(*from._impl_.use_case_); + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void UseCaseEvent::CopyFrom(const UseCaseEvent& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:control_service.UseCaseEvent) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void UseCaseEvent::InternalSwap(UseCaseEvent* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.event_, &other->_impl_.event_, arena); + swap(_impl_.use_case_, other->_impl_.use_case_); +} + +::google::protobuf::Metadata UseCaseEvent::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +DeviceCategory CreateDeviceCategory() { + DeviceCategory res; + return res; +} + +EntityType CreateEntityType() { + EntityType res; + return res; +} + +DeviceType CreateDeviceType() { + DeviceType res; + return res; +} + +UseCase CreateUseCase( + control_service::UseCase::ActorType::Enum actor, + control_service::UseCase::NameType::Enum name) { + UseCase res; + res.set_actor(actor); + res.set_name(name); + return res; +} + +UseCaseEvent CreateUseCaseEvent( + control_service::UseCase* use_case, + std::string event) { + UseCaseEvent res; + res.set_allocated_use_case(use_case); + res.set_event(event); + return res; +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace control_service +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_control_5fservice_2ftypes_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.h new file mode 100644 index 0000000000..582bb3a415 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.h @@ -0,0 +1,2079 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: control_service/types.proto +// Protobuf C++ Version: 5.29.0 + +#ifndef control_5fservice_2ftypes_2eproto_2epb_2eh +#define control_5fservice_2ftypes_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029000 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_bases.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/generated_enum_reflection.h" +#include "google/protobuf/unknown_field_set.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_control_5fservice_2ftypes_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_control_5fservice_2ftypes_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_control_5fservice_2ftypes_2eproto; +namespace control_service { +class DeviceCategory; +struct DeviceCategoryDefaultTypeInternal; +extern DeviceCategoryDefaultTypeInternal _DeviceCategory_default_instance_; +class DeviceType; +struct DeviceTypeDefaultTypeInternal; +extern DeviceTypeDefaultTypeInternal _DeviceType_default_instance_; +class EntityType; +struct EntityTypeDefaultTypeInternal; +extern EntityTypeDefaultTypeInternal _EntityType_default_instance_; +class UseCase; +struct UseCaseDefaultTypeInternal; +extern UseCaseDefaultTypeInternal _UseCase_default_instance_; +class UseCaseEvent; +struct UseCaseEventDefaultTypeInternal; +extern UseCaseEventDefaultTypeInternal _UseCaseEvent_default_instance_; +class UseCase_ActorType; +struct UseCase_ActorTypeDefaultTypeInternal; +extern UseCase_ActorTypeDefaultTypeInternal _UseCase_ActorType_default_instance_; +class UseCase_NameType; +struct UseCase_NameTypeDefaultTypeInternal; +extern UseCase_NameTypeDefaultTypeInternal _UseCase_NameType_default_instance_; +} // namespace control_service +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace control_service { +enum DeviceCategory_Enum : int { + DeviceCategory_Enum_UNKNOWN = 0, + DeviceCategory_Enum_GRID_CONNECTION_HUB = 1, + DeviceCategory_Enum_ENERGY_MANAGEMENT_SYSTEM = 2, + DeviceCategory_Enum_E_MOBILITY = 3, + DeviceCategory_Enum_HVAC = 4, + DeviceCategory_Enum_INVERTER = 5, + DeviceCategory_Enum_DOMESTIC_APPLIANCE = 6, + DeviceCategory_Enum_METERING = 7, + DeviceCategory_Enum_DeviceCategory_Enum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + DeviceCategory_Enum_DeviceCategory_Enum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool DeviceCategory_Enum_IsValid(int value); +extern const uint32_t DeviceCategory_Enum_internal_data_[]; +constexpr DeviceCategory_Enum DeviceCategory_Enum_Enum_MIN = static_cast(0); +constexpr DeviceCategory_Enum DeviceCategory_Enum_Enum_MAX = static_cast(7); +constexpr int DeviceCategory_Enum_Enum_ARRAYSIZE = 7 + 1; +const ::google::protobuf::EnumDescriptor* +DeviceCategory_Enum_descriptor(); +template +const std::string& DeviceCategory_Enum_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Enum_Name()."); + return DeviceCategory_Enum_Name(static_cast(value)); +} +template <> +inline const std::string& DeviceCategory_Enum_Name(DeviceCategory_Enum value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool DeviceCategory_Enum_Parse(absl::string_view name, DeviceCategory_Enum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + DeviceCategory_Enum_descriptor(), name, value); +} +enum EntityType_Enum : int { + EntityType_Enum_UNKNOWN = 0, + EntityType_Enum_Battery = 1, + EntityType_Enum_Compressor = 2, + EntityType_Enum_DeviceInformation = 3, + EntityType_Enum_DHWCircuit = 4, + EntityType_Enum_DHWStorage = 5, + EntityType_Enum_Dishwasher = 6, + EntityType_Enum_Dryer = 7, + EntityType_Enum_ElectricalImmersionHeater = 8, + EntityType_Enum_Fan = 9, + EntityType_Enum_GasHeatingAppliance = 10, + EntityType_Enum_Generic = 11, + EntityType_Enum_HeatingBufferStorage = 12, + EntityType_Enum_HeatingCircuit = 13, + EntityType_Enum_HeatingObject = 14, + EntityType_Enum_HeatingZone = 15, + EntityType_Enum_HeatPumpAppliance = 16, + EntityType_Enum_HeatSinkCircuit = 17, + EntityType_Enum_HeatSourceCircuit = 18, + EntityType_Enum_HeatSourceUnit = 19, + EntityType_Enum_HvacController = 20, + EntityType_Enum_HvacRoom = 21, + EntityType_Enum_InstantDHWHeater = 22, + EntityType_Enum_Inverter = 23, + EntityType_Enum_OilHeatingAppliance = 24, + EntityType_Enum_Pump = 25, + EntityType_Enum_RefrigerantCircuit = 26, + EntityType_Enum_SmartEnergyAppliance = 27, + EntityType_Enum_SolarDHWStorage = 28, + EntityType_Enum_SolarThermalCircuit = 29, + EntityType_Enum_SubMeterElectricity = 30, + EntityType_Enum_TemperatureSensor = 31, + EntityType_Enum_Washer = 32, + EntityType_Enum_BatterySystem = 33, + EntityType_Enum_ElectricityGenerationSystem = 34, + EntityType_Enum_ElectricityStorageSystem = 35, + EntityType_Enum_GridConnectionPointOfPremises = 36, + EntityType_Enum_Household = 37, + EntityType_Enum_PVSystem = 38, + EntityType_Enum_EV = 39, + EntityType_Enum_EVSE = 40, + EntityType_Enum_ChargingOutlet = 41, + EntityType_Enum_CEM = 42, + EntityType_Enum_PV = 43, + EntityType_Enum_PVESHybrid = 44, + EntityType_Enum_ElectricalStorage = 45, + EntityType_Enum_PVString = 46, + EntityType_Enum_GridGuard = 47, + EntityType_Enum_ControllableSystem = 48, + EntityType_Enum_EntityType_Enum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + EntityType_Enum_EntityType_Enum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool EntityType_Enum_IsValid(int value); +extern const uint32_t EntityType_Enum_internal_data_[]; +constexpr EntityType_Enum EntityType_Enum_Enum_MIN = static_cast(0); +constexpr EntityType_Enum EntityType_Enum_Enum_MAX = static_cast(48); +constexpr int EntityType_Enum_Enum_ARRAYSIZE = 48 + 1; +const ::google::protobuf::EnumDescriptor* +EntityType_Enum_descriptor(); +template +const std::string& EntityType_Enum_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Enum_Name()."); + return EntityType_Enum_Name(static_cast(value)); +} +template <> +inline const std::string& EntityType_Enum_Name(EntityType_Enum value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool EntityType_Enum_Parse(absl::string_view name, EntityType_Enum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + EntityType_Enum_descriptor(), name, value); +} +enum DeviceType_Enum : int { + DeviceType_Enum_UNKNOWN = 0, + DeviceType_Enum_DISHWASHER = 1, + DeviceType_Enum_DRYER = 2, + DeviceType_Enum_ENVIRONMENT_SENSOR = 3, + DeviceType_Enum_GENERIC = 4, + DeviceType_Enum_HEAT_GENERATION_SYSTEM = 5, + DeviceType_Enum_HEAT_SINK_SYSTEM = 6, + DeviceType_Enum_HEAT_STORAGE_SYSTEM = 7, + DeviceType_Enum_HVAC_CONTROLLER = 8, + DeviceType_Enum_SUBMETER = 9, + DeviceType_Enum_WASHER = 10, + DeviceType_Enum_ELECTRICITY_SUPPLY_SYSTEM = 11, + DeviceType_Enum_ENERGY_MANAGEMENT_SYSTEM = 12, + DeviceType_Enum_INVERTER = 13, + DeviceType_Enum_CHARGING_STATION = 14, + DeviceType_Enum_DeviceType_Enum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + DeviceType_Enum_DeviceType_Enum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool DeviceType_Enum_IsValid(int value); +extern const uint32_t DeviceType_Enum_internal_data_[]; +constexpr DeviceType_Enum DeviceType_Enum_Enum_MIN = static_cast(0); +constexpr DeviceType_Enum DeviceType_Enum_Enum_MAX = static_cast(14); +constexpr int DeviceType_Enum_Enum_ARRAYSIZE = 14 + 1; +const ::google::protobuf::EnumDescriptor* +DeviceType_Enum_descriptor(); +template +const std::string& DeviceType_Enum_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Enum_Name()."); + return DeviceType_Enum_Name(static_cast(value)); +} +template <> +inline const std::string& DeviceType_Enum_Name(DeviceType_Enum value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool DeviceType_Enum_Parse(absl::string_view name, DeviceType_Enum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + DeviceType_Enum_descriptor(), name, value); +} +enum UseCase_ActorType_Enum : int { + UseCase_ActorType_Enum_UNKNOWN = 0, + UseCase_ActorType_Enum_Battery = 1, + UseCase_ActorType_Enum_BatterySystem = 2, + UseCase_ActorType_Enum_CEM = 3, + UseCase_ActorType_Enum_ConfigurationAppliance = 4, + UseCase_ActorType_Enum_Compressor = 5, + UseCase_ActorType_Enum_ControllableSystem = 6, + UseCase_ActorType_Enum_DHWCircuit = 7, + UseCase_ActorType_Enum_EnergyBroker = 8, + UseCase_ActorType_Enum_EnergyConsumer = 9, + UseCase_ActorType_Enum_EnergyGuard = 10, + UseCase_ActorType_Enum_EVSE = 11, + UseCase_ActorType_Enum_EV = 12, + UseCase_ActorType_Enum_GridConnectionPoint = 13, + UseCase_ActorType_Enum_HeatPump = 14, + UseCase_ActorType_Enum_HeatingCircuit = 15, + UseCase_ActorType_Enum_HeatingZone = 16, + UseCase_ActorType_Enum_HVACRoom = 17, + UseCase_ActorType_Enum_Inverter = 18, + UseCase_ActorType_Enum_MonitoredUnit = 19, + UseCase_ActorType_Enum_MonitoringAppliance = 20, + UseCase_ActorType_Enum_OutdoorTemperatureSensor = 21, + UseCase_ActorType_Enum_PVString = 22, + UseCase_ActorType_Enum_PVSystem = 23, + UseCase_ActorType_Enum_SmartAppliance = 24, + UseCase_ActorType_Enum_VisualizationAppliance = 25, + UseCase_ActorType_Enum_UseCase_ActorType_Enum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + UseCase_ActorType_Enum_UseCase_ActorType_Enum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool UseCase_ActorType_Enum_IsValid(int value); +extern const uint32_t UseCase_ActorType_Enum_internal_data_[]; +constexpr UseCase_ActorType_Enum UseCase_ActorType_Enum_Enum_MIN = static_cast(0); +constexpr UseCase_ActorType_Enum UseCase_ActorType_Enum_Enum_MAX = static_cast(25); +constexpr int UseCase_ActorType_Enum_Enum_ARRAYSIZE = 25 + 1; +const ::google::protobuf::EnumDescriptor* +UseCase_ActorType_Enum_descriptor(); +template +const std::string& UseCase_ActorType_Enum_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Enum_Name()."); + return UseCase_ActorType_Enum_Name(static_cast(value)); +} +template <> +inline const std::string& UseCase_ActorType_Enum_Name(UseCase_ActorType_Enum value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool UseCase_ActorType_Enum_Parse(absl::string_view name, UseCase_ActorType_Enum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + UseCase_ActorType_Enum_descriptor(), name, value); +} +enum UseCase_NameType_Enum : int { + UseCase_NameType_Enum_UNKNOWN = 0, + UseCase_NameType_Enum_configurationOfDhwSystemFunction = 1, + UseCase_NameType_Enum_configurationOfDhwTemperature = 2, + UseCase_NameType_Enum_configurationOfRoomCoolingSystemFunction = 3, + UseCase_NameType_Enum_configurationOfRoomCoolingTemperature = 4, + UseCase_NameType_Enum_configurationOfRoomHeatingSystemFunction = 5, + UseCase_NameType_Enum_configurationOfRoomHeatingTemperature = 6, + UseCase_NameType_Enum_controlOfBattery = 7, + UseCase_NameType_Enum_coordinatedEvCharging = 8, + UseCase_NameType_Enum_evChargingSummary = 9, + UseCase_NameType_Enum_evCommissioningAndConfiguration = 10, + UseCase_NameType_Enum_evseCommissioningAndConfiguration = 11, + UseCase_NameType_Enum_evStateOfCharge = 12, + UseCase_NameType_Enum_flexibleLoad = 13, + UseCase_NameType_Enum_flexibleStartForWhiteGoods = 14, + UseCase_NameType_Enum_limitationOfPowerConsumption = 15, + UseCase_NameType_Enum_limitationOfPowerProduction = 16, + UseCase_NameType_Enum_incentiveTableBasedPowerConsumptionManagement = 17, + UseCase_NameType_Enum_measurementOfElectricityDuringEvCharging = 18, + UseCase_NameType_Enum_monitoringAndControlOfSmartGridReadyConditions = 19, + UseCase_NameType_Enum_monitoringOfBattery = 20, + UseCase_NameType_Enum_monitoringOfDhwSystemFunction = 21, + UseCase_NameType_Enum_monitoringOfDhwTemperature = 22, + UseCase_NameType_Enum_monitoringOfGridConnectionPoint = 23, + UseCase_NameType_Enum_monitoringOfInverter = 24, + UseCase_NameType_Enum_monitoringOfOutdoorTemperature = 25, + UseCase_NameType_Enum_monitoringOfPowerConsumption = 26, + UseCase_NameType_Enum_monitoringOfPvString = 27, + UseCase_NameType_Enum_monitoringOfRoomCoolingSystemFunction = 28, + UseCase_NameType_Enum_monitoringOfRoomHeatingSystemFunction = 29, + UseCase_NameType_Enum_monitoringOfRoomTemperature = 30, + UseCase_NameType_Enum_optimizationOfSelfConsumptionByHeatPumpCompressorFlexibility = 31, + UseCase_NameType_Enum_optimizationOfSelfConsumptionDuringEvCharging = 32, + UseCase_NameType_Enum_overloadProtectionByEvChargingCurrentCurtailment = 33, + UseCase_NameType_Enum_visualizationOfAggregatedBatteryData = 34, + UseCase_NameType_Enum_visualizationOfAggregatedPhotovoltaicData = 35, + UseCase_NameType_Enum_visualizationOfHeatingAreaName = 36, + UseCase_NameType_Enum_UseCase_NameType_Enum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + UseCase_NameType_Enum_UseCase_NameType_Enum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool UseCase_NameType_Enum_IsValid(int value); +extern const uint32_t UseCase_NameType_Enum_internal_data_[]; +constexpr UseCase_NameType_Enum UseCase_NameType_Enum_Enum_MIN = static_cast(0); +constexpr UseCase_NameType_Enum UseCase_NameType_Enum_Enum_MAX = static_cast(36); +constexpr int UseCase_NameType_Enum_Enum_ARRAYSIZE = 36 + 1; +const ::google::protobuf::EnumDescriptor* +UseCase_NameType_Enum_descriptor(); +template +const std::string& UseCase_NameType_Enum_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Enum_Name()."); + return UseCase_NameType_Enum_Name(static_cast(value)); +} +template <> +inline const std::string& UseCase_NameType_Enum_Name(UseCase_NameType_Enum value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool UseCase_NameType_Enum_Parse(absl::string_view name, UseCase_NameType_Enum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + UseCase_NameType_Enum_descriptor(), name, value); +} +enum SharedType : int { + INVERTER = 0, + SharedType_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + SharedType_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool SharedType_IsValid(int value); +extern const uint32_t SharedType_internal_data_[]; +constexpr SharedType SharedType_MIN = static_cast(0); +constexpr SharedType SharedType_MAX = static_cast(0); +constexpr int SharedType_ARRAYSIZE = 0 + 1; +const ::google::protobuf::EnumDescriptor* +SharedType_descriptor(); +template +const std::string& SharedType_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to SharedType_Name()."); + return SharedType_Name(static_cast(value)); +} +template <> +inline const std::string& SharedType_Name(SharedType value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool SharedType_Parse(absl::string_view name, SharedType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SharedType_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class UseCase_NameType final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.UseCase.NameType) */ { + public: + inline UseCase_NameType() : UseCase_NameType(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UseCase_NameType* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UseCase_NameType)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UseCase_NameType( + ::google::protobuf::internal::ConstantInitialized); + + inline UseCase_NameType(const UseCase_NameType& from) : UseCase_NameType(nullptr, from) {} + inline UseCase_NameType(UseCase_NameType&& from) noexcept + : UseCase_NameType(nullptr, std::move(from)) {} + inline UseCase_NameType& operator=(const UseCase_NameType& from) { + CopyFrom(from); + return *this; + } + inline UseCase_NameType& operator=(UseCase_NameType&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const UseCase_NameType& default_instance() { + return *internal_default_instance(); + } + static inline const UseCase_NameType* internal_default_instance() { + return reinterpret_cast( + &_UseCase_NameType_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + friend void swap(UseCase_NameType& a, UseCase_NameType& b) { a.Swap(&b); } + inline void Swap(UseCase_NameType* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UseCase_NameType* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UseCase_NameType* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const UseCase_NameType& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const UseCase_NameType& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.UseCase.NameType"; } + + protected: + explicit UseCase_NameType(::google::protobuf::Arena* arena); + UseCase_NameType(::google::protobuf::Arena* arena, const UseCase_NameType& from); + UseCase_NameType(::google::protobuf::Arena* arena, UseCase_NameType&& from) noexcept + : UseCase_NameType(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using Enum = UseCase_NameType_Enum; + static constexpr Enum UNKNOWN = UseCase_NameType_Enum_UNKNOWN; + static constexpr Enum configurationOfDhwSystemFunction = UseCase_NameType_Enum_configurationOfDhwSystemFunction; + static constexpr Enum configurationOfDhwTemperature = UseCase_NameType_Enum_configurationOfDhwTemperature; + static constexpr Enum configurationOfRoomCoolingSystemFunction = UseCase_NameType_Enum_configurationOfRoomCoolingSystemFunction; + static constexpr Enum configurationOfRoomCoolingTemperature = UseCase_NameType_Enum_configurationOfRoomCoolingTemperature; + static constexpr Enum configurationOfRoomHeatingSystemFunction = UseCase_NameType_Enum_configurationOfRoomHeatingSystemFunction; + static constexpr Enum configurationOfRoomHeatingTemperature = UseCase_NameType_Enum_configurationOfRoomHeatingTemperature; + static constexpr Enum controlOfBattery = UseCase_NameType_Enum_controlOfBattery; + static constexpr Enum coordinatedEvCharging = UseCase_NameType_Enum_coordinatedEvCharging; + static constexpr Enum evChargingSummary = UseCase_NameType_Enum_evChargingSummary; + static constexpr Enum evCommissioningAndConfiguration = UseCase_NameType_Enum_evCommissioningAndConfiguration; + static constexpr Enum evseCommissioningAndConfiguration = UseCase_NameType_Enum_evseCommissioningAndConfiguration; + static constexpr Enum evStateOfCharge = UseCase_NameType_Enum_evStateOfCharge; + static constexpr Enum flexibleLoad = UseCase_NameType_Enum_flexibleLoad; + static constexpr Enum flexibleStartForWhiteGoods = UseCase_NameType_Enum_flexibleStartForWhiteGoods; + static constexpr Enum limitationOfPowerConsumption = UseCase_NameType_Enum_limitationOfPowerConsumption; + static constexpr Enum limitationOfPowerProduction = UseCase_NameType_Enum_limitationOfPowerProduction; + static constexpr Enum incentiveTableBasedPowerConsumptionManagement = UseCase_NameType_Enum_incentiveTableBasedPowerConsumptionManagement; + static constexpr Enum measurementOfElectricityDuringEvCharging = UseCase_NameType_Enum_measurementOfElectricityDuringEvCharging; + static constexpr Enum monitoringAndControlOfSmartGridReadyConditions = UseCase_NameType_Enum_monitoringAndControlOfSmartGridReadyConditions; + static constexpr Enum monitoringOfBattery = UseCase_NameType_Enum_monitoringOfBattery; + static constexpr Enum monitoringOfDhwSystemFunction = UseCase_NameType_Enum_monitoringOfDhwSystemFunction; + static constexpr Enum monitoringOfDhwTemperature = UseCase_NameType_Enum_monitoringOfDhwTemperature; + static constexpr Enum monitoringOfGridConnectionPoint = UseCase_NameType_Enum_monitoringOfGridConnectionPoint; + static constexpr Enum monitoringOfInverter = UseCase_NameType_Enum_monitoringOfInverter; + static constexpr Enum monitoringOfOutdoorTemperature = UseCase_NameType_Enum_monitoringOfOutdoorTemperature; + static constexpr Enum monitoringOfPowerConsumption = UseCase_NameType_Enum_monitoringOfPowerConsumption; + static constexpr Enum monitoringOfPvString = UseCase_NameType_Enum_monitoringOfPvString; + static constexpr Enum monitoringOfRoomCoolingSystemFunction = UseCase_NameType_Enum_monitoringOfRoomCoolingSystemFunction; + static constexpr Enum monitoringOfRoomHeatingSystemFunction = UseCase_NameType_Enum_monitoringOfRoomHeatingSystemFunction; + static constexpr Enum monitoringOfRoomTemperature = UseCase_NameType_Enum_monitoringOfRoomTemperature; + static constexpr Enum optimizationOfSelfConsumptionByHeatPumpCompressorFlexibility = UseCase_NameType_Enum_optimizationOfSelfConsumptionByHeatPumpCompressorFlexibility; + static constexpr Enum optimizationOfSelfConsumptionDuringEvCharging = UseCase_NameType_Enum_optimizationOfSelfConsumptionDuringEvCharging; + static constexpr Enum overloadProtectionByEvChargingCurrentCurtailment = UseCase_NameType_Enum_overloadProtectionByEvChargingCurrentCurtailment; + static constexpr Enum visualizationOfAggregatedBatteryData = UseCase_NameType_Enum_visualizationOfAggregatedBatteryData; + static constexpr Enum visualizationOfAggregatedPhotovoltaicData = UseCase_NameType_Enum_visualizationOfAggregatedPhotovoltaicData; + static constexpr Enum visualizationOfHeatingAreaName = UseCase_NameType_Enum_visualizationOfHeatingAreaName; + static inline bool Enum_IsValid(int value) { + return UseCase_NameType_Enum_IsValid(value); + } + static constexpr Enum Enum_MIN = UseCase_NameType_Enum_Enum_MIN; + static constexpr Enum Enum_MAX = UseCase_NameType_Enum_Enum_MAX; + static constexpr int Enum_ARRAYSIZE = UseCase_NameType_Enum_Enum_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Enum_descriptor() { + return UseCase_NameType_Enum_descriptor(); + } + template + static inline const std::string& Enum_Name(T value) { + return UseCase_NameType_Enum_Name(value); + } + static inline bool Enum_Parse(absl::string_view name, Enum* value) { + return UseCase_NameType_Enum_Parse(name, value); + } + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.UseCase.NameType) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UseCase_NameType& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class UseCase_ActorType final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.UseCase.ActorType) */ { + public: + inline UseCase_ActorType() : UseCase_ActorType(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UseCase_ActorType* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UseCase_ActorType)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UseCase_ActorType( + ::google::protobuf::internal::ConstantInitialized); + + inline UseCase_ActorType(const UseCase_ActorType& from) : UseCase_ActorType(nullptr, from) {} + inline UseCase_ActorType(UseCase_ActorType&& from) noexcept + : UseCase_ActorType(nullptr, std::move(from)) {} + inline UseCase_ActorType& operator=(const UseCase_ActorType& from) { + CopyFrom(from); + return *this; + } + inline UseCase_ActorType& operator=(UseCase_ActorType&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const UseCase_ActorType& default_instance() { + return *internal_default_instance(); + } + static inline const UseCase_ActorType* internal_default_instance() { + return reinterpret_cast( + &_UseCase_ActorType_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(UseCase_ActorType& a, UseCase_ActorType& b) { a.Swap(&b); } + inline void Swap(UseCase_ActorType* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UseCase_ActorType* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UseCase_ActorType* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const UseCase_ActorType& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const UseCase_ActorType& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.UseCase.ActorType"; } + + protected: + explicit UseCase_ActorType(::google::protobuf::Arena* arena); + UseCase_ActorType(::google::protobuf::Arena* arena, const UseCase_ActorType& from); + UseCase_ActorType(::google::protobuf::Arena* arena, UseCase_ActorType&& from) noexcept + : UseCase_ActorType(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using Enum = UseCase_ActorType_Enum; + static constexpr Enum UNKNOWN = UseCase_ActorType_Enum_UNKNOWN; + static constexpr Enum Battery = UseCase_ActorType_Enum_Battery; + static constexpr Enum BatterySystem = UseCase_ActorType_Enum_BatterySystem; + static constexpr Enum CEM = UseCase_ActorType_Enum_CEM; + static constexpr Enum ConfigurationAppliance = UseCase_ActorType_Enum_ConfigurationAppliance; + static constexpr Enum Compressor = UseCase_ActorType_Enum_Compressor; + static constexpr Enum ControllableSystem = UseCase_ActorType_Enum_ControllableSystem; + static constexpr Enum DHWCircuit = UseCase_ActorType_Enum_DHWCircuit; + static constexpr Enum EnergyBroker = UseCase_ActorType_Enum_EnergyBroker; + static constexpr Enum EnergyConsumer = UseCase_ActorType_Enum_EnergyConsumer; + static constexpr Enum EnergyGuard = UseCase_ActorType_Enum_EnergyGuard; + static constexpr Enum EVSE = UseCase_ActorType_Enum_EVSE; + static constexpr Enum EV = UseCase_ActorType_Enum_EV; + static constexpr Enum GridConnectionPoint = UseCase_ActorType_Enum_GridConnectionPoint; + static constexpr Enum HeatPump = UseCase_ActorType_Enum_HeatPump; + static constexpr Enum HeatingCircuit = UseCase_ActorType_Enum_HeatingCircuit; + static constexpr Enum HeatingZone = UseCase_ActorType_Enum_HeatingZone; + static constexpr Enum HVACRoom = UseCase_ActorType_Enum_HVACRoom; + static constexpr Enum Inverter = UseCase_ActorType_Enum_Inverter; + static constexpr Enum MonitoredUnit = UseCase_ActorType_Enum_MonitoredUnit; + static constexpr Enum MonitoringAppliance = UseCase_ActorType_Enum_MonitoringAppliance; + static constexpr Enum OutdoorTemperatureSensor = UseCase_ActorType_Enum_OutdoorTemperatureSensor; + static constexpr Enum PVString = UseCase_ActorType_Enum_PVString; + static constexpr Enum PVSystem = UseCase_ActorType_Enum_PVSystem; + static constexpr Enum SmartAppliance = UseCase_ActorType_Enum_SmartAppliance; + static constexpr Enum VisualizationAppliance = UseCase_ActorType_Enum_VisualizationAppliance; + static inline bool Enum_IsValid(int value) { + return UseCase_ActorType_Enum_IsValid(value); + } + static constexpr Enum Enum_MIN = UseCase_ActorType_Enum_Enum_MIN; + static constexpr Enum Enum_MAX = UseCase_ActorType_Enum_Enum_MAX; + static constexpr int Enum_ARRAYSIZE = UseCase_ActorType_Enum_Enum_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Enum_descriptor() { + return UseCase_ActorType_Enum_descriptor(); + } + template + static inline const std::string& Enum_Name(T value) { + return UseCase_ActorType_Enum_Name(value); + } + static inline bool Enum_Parse(absl::string_view name, Enum* value) { + return UseCase_ActorType_Enum_Parse(name, value); + } + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.UseCase.ActorType) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UseCase_ActorType& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class UseCase final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.UseCase) */ { + public: + inline UseCase() : UseCase(nullptr) {} + ~UseCase() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UseCase* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UseCase)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UseCase( + ::google::protobuf::internal::ConstantInitialized); + + inline UseCase(const UseCase& from) : UseCase(nullptr, from) {} + inline UseCase(UseCase&& from) noexcept + : UseCase(nullptr, std::move(from)) {} + inline UseCase& operator=(const UseCase& from) { + CopyFrom(from); + return *this; + } + inline UseCase& operator=(UseCase&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const UseCase& default_instance() { + return *internal_default_instance(); + } + static inline const UseCase* internal_default_instance() { + return reinterpret_cast( + &_UseCase_default_instance_); + } + static constexpr int kIndexInFileMessages = 5; + friend void swap(UseCase& a, UseCase& b) { a.Swap(&b); } + inline void Swap(UseCase* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UseCase* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UseCase* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const UseCase& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const UseCase& from) { UseCase::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UseCase* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.UseCase"; } + + protected: + explicit UseCase(::google::protobuf::Arena* arena); + UseCase(::google::protobuf::Arena* arena, const UseCase& from); + UseCase(::google::protobuf::Arena* arena, UseCase&& from) noexcept + : UseCase(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using ActorType = UseCase_ActorType; + using NameType = UseCase_NameType; + + // accessors ------------------------------------------------------- + enum : int { + kActorFieldNumber = 1, + kNameFieldNumber = 2, + }; + // .control_service.UseCase.ActorType.Enum actor = 1; + void clear_actor() ; + ::control_service::UseCase_ActorType_Enum actor() const; + void set_actor(::control_service::UseCase_ActorType_Enum value); + + private: + ::control_service::UseCase_ActorType_Enum _internal_actor() const; + void _internal_set_actor(::control_service::UseCase_ActorType_Enum value); + + public: + // .control_service.UseCase.NameType.Enum name = 2; + void clear_name() ; + ::control_service::UseCase_NameType_Enum name() const; + void set_name(::control_service::UseCase_NameType_Enum value); + + private: + ::control_service::UseCase_NameType_Enum _internal_name() const; + void _internal_set_name(::control_service::UseCase_NameType_Enum value); + + public: + // @@protoc_insertion_point(class_scope:control_service.UseCase) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UseCase& from_msg); + int actor_; + int name_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class EntityType final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.EntityType) */ { + public: + inline EntityType() : EntityType(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(EntityType* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(EntityType)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR EntityType( + ::google::protobuf::internal::ConstantInitialized); + + inline EntityType(const EntityType& from) : EntityType(nullptr, from) {} + inline EntityType(EntityType&& from) noexcept + : EntityType(nullptr, std::move(from)) {} + inline EntityType& operator=(const EntityType& from) { + CopyFrom(from); + return *this; + } + inline EntityType& operator=(EntityType&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EntityType& default_instance() { + return *internal_default_instance(); + } + static inline const EntityType* internal_default_instance() { + return reinterpret_cast( + &_EntityType_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(EntityType& a, EntityType& b) { a.Swap(&b); } + inline void Swap(EntityType* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EntityType* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EntityType* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const EntityType& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const EntityType& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.EntityType"; } + + protected: + explicit EntityType(::google::protobuf::Arena* arena); + EntityType(::google::protobuf::Arena* arena, const EntityType& from); + EntityType(::google::protobuf::Arena* arena, EntityType&& from) noexcept + : EntityType(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using Enum = EntityType_Enum; + static constexpr Enum UNKNOWN = EntityType_Enum_UNKNOWN; + static constexpr Enum Battery = EntityType_Enum_Battery; + static constexpr Enum Compressor = EntityType_Enum_Compressor; + static constexpr Enum DeviceInformation = EntityType_Enum_DeviceInformation; + static constexpr Enum DHWCircuit = EntityType_Enum_DHWCircuit; + static constexpr Enum DHWStorage = EntityType_Enum_DHWStorage; + static constexpr Enum Dishwasher = EntityType_Enum_Dishwasher; + static constexpr Enum Dryer = EntityType_Enum_Dryer; + static constexpr Enum ElectricalImmersionHeater = EntityType_Enum_ElectricalImmersionHeater; + static constexpr Enum Fan = EntityType_Enum_Fan; + static constexpr Enum GasHeatingAppliance = EntityType_Enum_GasHeatingAppliance; + static constexpr Enum Generic = EntityType_Enum_Generic; + static constexpr Enum HeatingBufferStorage = EntityType_Enum_HeatingBufferStorage; + static constexpr Enum HeatingCircuit = EntityType_Enum_HeatingCircuit; + static constexpr Enum HeatingObject = EntityType_Enum_HeatingObject; + static constexpr Enum HeatingZone = EntityType_Enum_HeatingZone; + static constexpr Enum HeatPumpAppliance = EntityType_Enum_HeatPumpAppliance; + static constexpr Enum HeatSinkCircuit = EntityType_Enum_HeatSinkCircuit; + static constexpr Enum HeatSourceCircuit = EntityType_Enum_HeatSourceCircuit; + static constexpr Enum HeatSourceUnit = EntityType_Enum_HeatSourceUnit; + static constexpr Enum HvacController = EntityType_Enum_HvacController; + static constexpr Enum HvacRoom = EntityType_Enum_HvacRoom; + static constexpr Enum InstantDHWHeater = EntityType_Enum_InstantDHWHeater; + static constexpr Enum Inverter = EntityType_Enum_Inverter; + static constexpr Enum OilHeatingAppliance = EntityType_Enum_OilHeatingAppliance; + static constexpr Enum Pump = EntityType_Enum_Pump; + static constexpr Enum RefrigerantCircuit = EntityType_Enum_RefrigerantCircuit; + static constexpr Enum SmartEnergyAppliance = EntityType_Enum_SmartEnergyAppliance; + static constexpr Enum SolarDHWStorage = EntityType_Enum_SolarDHWStorage; + static constexpr Enum SolarThermalCircuit = EntityType_Enum_SolarThermalCircuit; + static constexpr Enum SubMeterElectricity = EntityType_Enum_SubMeterElectricity; + static constexpr Enum TemperatureSensor = EntityType_Enum_TemperatureSensor; + static constexpr Enum Washer = EntityType_Enum_Washer; + static constexpr Enum BatterySystem = EntityType_Enum_BatterySystem; + static constexpr Enum ElectricityGenerationSystem = EntityType_Enum_ElectricityGenerationSystem; + static constexpr Enum ElectricityStorageSystem = EntityType_Enum_ElectricityStorageSystem; + static constexpr Enum GridConnectionPointOfPremises = EntityType_Enum_GridConnectionPointOfPremises; + static constexpr Enum Household = EntityType_Enum_Household; + static constexpr Enum PVSystem = EntityType_Enum_PVSystem; + static constexpr Enum EV = EntityType_Enum_EV; + static constexpr Enum EVSE = EntityType_Enum_EVSE; + static constexpr Enum ChargingOutlet = EntityType_Enum_ChargingOutlet; + static constexpr Enum CEM = EntityType_Enum_CEM; + static constexpr Enum PV = EntityType_Enum_PV; + static constexpr Enum PVESHybrid = EntityType_Enum_PVESHybrid; + static constexpr Enum ElectricalStorage = EntityType_Enum_ElectricalStorage; + static constexpr Enum PVString = EntityType_Enum_PVString; + static constexpr Enum GridGuard = EntityType_Enum_GridGuard; + static constexpr Enum ControllableSystem = EntityType_Enum_ControllableSystem; + static inline bool Enum_IsValid(int value) { + return EntityType_Enum_IsValid(value); + } + static constexpr Enum Enum_MIN = EntityType_Enum_Enum_MIN; + static constexpr Enum Enum_MAX = EntityType_Enum_Enum_MAX; + static constexpr int Enum_ARRAYSIZE = EntityType_Enum_Enum_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Enum_descriptor() { + return EntityType_Enum_descriptor(); + } + template + static inline const std::string& Enum_Name(T value) { + return EntityType_Enum_Name(value); + } + static inline bool Enum_Parse(absl::string_view name, Enum* value) { + return EntityType_Enum_Parse(name, value); + } + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.EntityType) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const EntityType& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class DeviceType final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.DeviceType) */ { + public: + inline DeviceType() : DeviceType(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DeviceType* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DeviceType)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR DeviceType( + ::google::protobuf::internal::ConstantInitialized); + + inline DeviceType(const DeviceType& from) : DeviceType(nullptr, from) {} + inline DeviceType(DeviceType&& from) noexcept + : DeviceType(nullptr, std::move(from)) {} + inline DeviceType& operator=(const DeviceType& from) { + CopyFrom(from); + return *this; + } + inline DeviceType& operator=(DeviceType&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DeviceType& default_instance() { + return *internal_default_instance(); + } + static inline const DeviceType* internal_default_instance() { + return reinterpret_cast( + &_DeviceType_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(DeviceType& a, DeviceType& b) { a.Swap(&b); } + inline void Swap(DeviceType* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DeviceType* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DeviceType* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const DeviceType& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const DeviceType& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.DeviceType"; } + + protected: + explicit DeviceType(::google::protobuf::Arena* arena); + DeviceType(::google::protobuf::Arena* arena, const DeviceType& from); + DeviceType(::google::protobuf::Arena* arena, DeviceType&& from) noexcept + : DeviceType(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using Enum = DeviceType_Enum; + static constexpr Enum UNKNOWN = DeviceType_Enum_UNKNOWN; + static constexpr Enum DISHWASHER = DeviceType_Enum_DISHWASHER; + static constexpr Enum DRYER = DeviceType_Enum_DRYER; + static constexpr Enum ENVIRONMENT_SENSOR = DeviceType_Enum_ENVIRONMENT_SENSOR; + static constexpr Enum GENERIC = DeviceType_Enum_GENERIC; + static constexpr Enum HEAT_GENERATION_SYSTEM = DeviceType_Enum_HEAT_GENERATION_SYSTEM; + static constexpr Enum HEAT_SINK_SYSTEM = DeviceType_Enum_HEAT_SINK_SYSTEM; + static constexpr Enum HEAT_STORAGE_SYSTEM = DeviceType_Enum_HEAT_STORAGE_SYSTEM; + static constexpr Enum HVAC_CONTROLLER = DeviceType_Enum_HVAC_CONTROLLER; + static constexpr Enum SUBMETER = DeviceType_Enum_SUBMETER; + static constexpr Enum WASHER = DeviceType_Enum_WASHER; + static constexpr Enum ELECTRICITY_SUPPLY_SYSTEM = DeviceType_Enum_ELECTRICITY_SUPPLY_SYSTEM; + static constexpr Enum ENERGY_MANAGEMENT_SYSTEM = DeviceType_Enum_ENERGY_MANAGEMENT_SYSTEM; + static constexpr Enum INVERTER = DeviceType_Enum_INVERTER; + static constexpr Enum CHARGING_STATION = DeviceType_Enum_CHARGING_STATION; + static inline bool Enum_IsValid(int value) { + return DeviceType_Enum_IsValid(value); + } + static constexpr Enum Enum_MIN = DeviceType_Enum_Enum_MIN; + static constexpr Enum Enum_MAX = DeviceType_Enum_Enum_MAX; + static constexpr int Enum_ARRAYSIZE = DeviceType_Enum_Enum_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Enum_descriptor() { + return DeviceType_Enum_descriptor(); + } + template + static inline const std::string& Enum_Name(T value) { + return DeviceType_Enum_Name(value); + } + static inline bool Enum_Parse(absl::string_view name, Enum* value) { + return DeviceType_Enum_Parse(name, value); + } + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.DeviceType) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const DeviceType& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class DeviceCategory final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:control_service.DeviceCategory) */ { + public: + inline DeviceCategory() : DeviceCategory(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DeviceCategory* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DeviceCategory)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR DeviceCategory( + ::google::protobuf::internal::ConstantInitialized); + + inline DeviceCategory(const DeviceCategory& from) : DeviceCategory(nullptr, from) {} + inline DeviceCategory(DeviceCategory&& from) noexcept + : DeviceCategory(nullptr, std::move(from)) {} + inline DeviceCategory& operator=(const DeviceCategory& from) { + CopyFrom(from); + return *this; + } + inline DeviceCategory& operator=(DeviceCategory&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DeviceCategory& default_instance() { + return *internal_default_instance(); + } + static inline const DeviceCategory* internal_default_instance() { + return reinterpret_cast( + &_DeviceCategory_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(DeviceCategory& a, DeviceCategory& b) { a.Swap(&b); } + inline void Swap(DeviceCategory* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DeviceCategory* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DeviceCategory* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const DeviceCategory& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const DeviceCategory& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.DeviceCategory"; } + + protected: + explicit DeviceCategory(::google::protobuf::Arena* arena); + DeviceCategory(::google::protobuf::Arena* arena, const DeviceCategory& from); + DeviceCategory(::google::protobuf::Arena* arena, DeviceCategory&& from) noexcept + : DeviceCategory(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + using Enum = DeviceCategory_Enum; + static constexpr Enum UNKNOWN = DeviceCategory_Enum_UNKNOWN; + static constexpr Enum GRID_CONNECTION_HUB = DeviceCategory_Enum_GRID_CONNECTION_HUB; + static constexpr Enum ENERGY_MANAGEMENT_SYSTEM = DeviceCategory_Enum_ENERGY_MANAGEMENT_SYSTEM; + static constexpr Enum E_MOBILITY = DeviceCategory_Enum_E_MOBILITY; + static constexpr Enum HVAC = DeviceCategory_Enum_HVAC; + static constexpr Enum INVERTER = DeviceCategory_Enum_INVERTER; + static constexpr Enum DOMESTIC_APPLIANCE = DeviceCategory_Enum_DOMESTIC_APPLIANCE; + static constexpr Enum METERING = DeviceCategory_Enum_METERING; + static inline bool Enum_IsValid(int value) { + return DeviceCategory_Enum_IsValid(value); + } + static constexpr Enum Enum_MIN = DeviceCategory_Enum_Enum_MIN; + static constexpr Enum Enum_MAX = DeviceCategory_Enum_Enum_MAX; + static constexpr int Enum_ARRAYSIZE = DeviceCategory_Enum_Enum_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Enum_descriptor() { + return DeviceCategory_Enum_descriptor(); + } + template + static inline const std::string& Enum_Name(T value) { + return DeviceCategory_Enum_Name(value); + } + static inline bool Enum_Parse(absl::string_view name, Enum* value) { + return DeviceCategory_Enum_Parse(name, value); + } + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:control_service.DeviceCategory) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const DeviceCategory& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class UseCaseEvent final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:control_service.UseCaseEvent) */ { + public: + inline UseCaseEvent() : UseCaseEvent(nullptr) {} + ~UseCaseEvent() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UseCaseEvent* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UseCaseEvent)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UseCaseEvent( + ::google::protobuf::internal::ConstantInitialized); + + inline UseCaseEvent(const UseCaseEvent& from) : UseCaseEvent(nullptr, from) {} + inline UseCaseEvent(UseCaseEvent&& from) noexcept + : UseCaseEvent(nullptr, std::move(from)) {} + inline UseCaseEvent& operator=(const UseCaseEvent& from) { + CopyFrom(from); + return *this; + } + inline UseCaseEvent& operator=(UseCaseEvent&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const UseCaseEvent& default_instance() { + return *internal_default_instance(); + } + static inline const UseCaseEvent* internal_default_instance() { + return reinterpret_cast( + &_UseCaseEvent_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(UseCaseEvent& a, UseCaseEvent& b) { a.Swap(&b); } + inline void Swap(UseCaseEvent* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UseCaseEvent* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UseCaseEvent* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const UseCaseEvent& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const UseCaseEvent& from) { UseCaseEvent::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UseCaseEvent* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "control_service.UseCaseEvent"; } + + protected: + explicit UseCaseEvent(::google::protobuf::Arena* arena); + UseCaseEvent(::google::protobuf::Arena* arena, const UseCaseEvent& from); + UseCaseEvent(::google::protobuf::Arena* arena, UseCaseEvent&& from) noexcept + : UseCaseEvent(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEventFieldNumber = 2, + kUseCaseFieldNumber = 1, + }; + // string event = 2; + void clear_event() ; + const std::string& event() const; + template + void set_event(Arg_&& arg, Args_... args); + std::string* mutable_event(); + PROTOBUF_NODISCARD std::string* release_event(); + void set_allocated_event(std::string* value); + + private: + const std::string& _internal_event() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_event( + const std::string& value); + std::string* _internal_mutable_event(); + + public: + // .control_service.UseCase use_case = 1; + bool has_use_case() const; + void clear_use_case() ; + const ::control_service::UseCase& use_case() const; + PROTOBUF_NODISCARD ::control_service::UseCase* release_use_case(); + ::control_service::UseCase* mutable_use_case(); + void set_allocated_use_case(::control_service::UseCase* value); + void unsafe_arena_set_allocated_use_case(::control_service::UseCase* value); + ::control_service::UseCase* unsafe_arena_release_use_case(); + + private: + const ::control_service::UseCase& _internal_use_case() const; + ::control_service::UseCase* _internal_mutable_use_case(); + + public: + // @@protoc_insertion_point(class_scope:control_service.UseCaseEvent) + 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; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UseCaseEvent& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr event_; + ::control_service::UseCase* use_case_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_control_5fservice_2ftypes_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// DeviceCategory + +// ------------------------------------------------------------------- + +// EntityType + +// ------------------------------------------------------------------- + +// DeviceType + +// ------------------------------------------------------------------- + +// UseCase_ActorType + +// ------------------------------------------------------------------- + +// UseCase_NameType + +// ------------------------------------------------------------------- + +// UseCase + +// .control_service.UseCase.ActorType.Enum actor = 1; +inline void UseCase::clear_actor() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.actor_ = 0; +} +inline ::control_service::UseCase_ActorType_Enum UseCase::actor() const { + // @@protoc_insertion_point(field_get:control_service.UseCase.actor) + return _internal_actor(); +} +inline void UseCase::set_actor(::control_service::UseCase_ActorType_Enum value) { + _internal_set_actor(value); + // @@protoc_insertion_point(field_set:control_service.UseCase.actor) +} +inline ::control_service::UseCase_ActorType_Enum UseCase::_internal_actor() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::control_service::UseCase_ActorType_Enum>(_impl_.actor_); +} +inline void UseCase::_internal_set_actor(::control_service::UseCase_ActorType_Enum value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.actor_ = value; +} + +// .control_service.UseCase.NameType.Enum name = 2; +inline void UseCase::clear_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_ = 0; +} +inline ::control_service::UseCase_NameType_Enum UseCase::name() const { + // @@protoc_insertion_point(field_get:control_service.UseCase.name) + return _internal_name(); +} +inline void UseCase::set_name(::control_service::UseCase_NameType_Enum value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:control_service.UseCase.name) +} +inline ::control_service::UseCase_NameType_Enum UseCase::_internal_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::control_service::UseCase_NameType_Enum>(_impl_.name_); +} +inline void UseCase::_internal_set_name(::control_service::UseCase_NameType_Enum value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_ = value; +} + +// ------------------------------------------------------------------- + +// UseCaseEvent + +// .control_service.UseCase use_case = 1; +inline bool UseCaseEvent::has_use_case() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.use_case_ != nullptr); + return value; +} +inline void UseCaseEvent::clear_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_ != nullptr) _impl_.use_case_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::control_service::UseCase& UseCaseEvent::_internal_use_case() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::control_service::UseCase* p = _impl_.use_case_; + return p != nullptr ? *p : reinterpret_cast(::control_service::_UseCase_default_instance_); +} +inline const ::control_service::UseCase& UseCaseEvent::use_case() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.UseCaseEvent.use_case) + return _internal_use_case(); +} +inline void UseCaseEvent::unsafe_arena_set_allocated_use_case(::control_service::UseCase* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.use_case_); + } + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:control_service.UseCaseEvent.use_case) +} +inline ::control_service::UseCase* UseCaseEvent::release_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::control_service::UseCase* released = _impl_.use_case_; + _impl_.use_case_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::control_service::UseCase* UseCaseEvent::unsafe_arena_release_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.UseCaseEvent.use_case) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::control_service::UseCase* temp = _impl_.use_case_; + _impl_.use_case_ = nullptr; + return temp; +} +inline ::control_service::UseCase* UseCaseEvent::_internal_mutable_use_case() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.use_case_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::control_service::UseCase>(GetArena()); + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(p); + } + return _impl_.use_case_; +} +inline ::control_service::UseCase* UseCaseEvent::mutable_use_case() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::control_service::UseCase* _msg = _internal_mutable_use_case(); + // @@protoc_insertion_point(field_mutable:control_service.UseCaseEvent.use_case) + return _msg; +} +inline void UseCaseEvent::set_allocated_use_case(::control_service::UseCase* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete (_impl_.use_case_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.use_case_ = reinterpret_cast<::control_service::UseCase*>(value); + // @@protoc_insertion_point(field_set_allocated:control_service.UseCaseEvent.use_case) +} + +// string event = 2; +inline void UseCaseEvent::clear_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.event_.ClearToEmpty(); +} +inline const std::string& UseCaseEvent::event() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:control_service.UseCaseEvent.event) + return _internal_event(); +} +template +inline PROTOBUF_ALWAYS_INLINE void UseCaseEvent::set_event(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.event_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:control_service.UseCaseEvent.event) +} +inline std::string* UseCaseEvent::mutable_event() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_event(); + // @@protoc_insertion_point(field_mutable:control_service.UseCaseEvent.event) + return _s; +} +inline const std::string& UseCaseEvent::_internal_event() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.event_.Get(); +} +inline void UseCaseEvent::_internal_set_event(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.event_.Set(value, GetArena()); +} +inline std::string* UseCaseEvent::_internal_mutable_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.event_.Mutable( GetArena()); +} +inline std::string* UseCaseEvent::release_event() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:control_service.UseCaseEvent.event) + return _impl_.event_.Release(); +} +inline void UseCaseEvent::set_allocated_event(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.event_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.event_.IsDefault()) { + _impl_.event_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:control_service.UseCaseEvent.event) +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +DeviceCategory CreateDeviceCategory(); + +EntityType CreateEntityType(); + +DeviceType CreateDeviceType(); + +UseCase CreateUseCase( + control_service::UseCase::ActorType::Enum actor, + control_service::UseCase::NameType::Enum name); + +UseCaseEvent CreateUseCaseEvent( + control_service::UseCase* use_case, + std::string event); + +// @@protoc_insertion_point(namespace_scope) +} // namespace control_service + + +namespace google { +namespace protobuf { + +template <> +struct is_proto_enum<::control_service::DeviceCategory_Enum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::control_service::DeviceCategory_Enum>() { + return ::control_service::DeviceCategory_Enum_descriptor(); +} +template <> +struct is_proto_enum<::control_service::EntityType_Enum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::control_service::EntityType_Enum>() { + return ::control_service::EntityType_Enum_descriptor(); +} +template <> +struct is_proto_enum<::control_service::DeviceType_Enum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::control_service::DeviceType_Enum>() { + return ::control_service::DeviceType_Enum_descriptor(); +} +template <> +struct is_proto_enum<::control_service::UseCase_ActorType_Enum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::control_service::UseCase_ActorType_Enum>() { + return ::control_service::UseCase_ActorType_Enum_descriptor(); +} +template <> +struct is_proto_enum<::control_service::UseCase_NameType_Enum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::control_service::UseCase_NameType_Enum>() { + return ::control_service::UseCase_NameType_Enum_descriptor(); +} +template <> +struct is_proto_enum<::control_service::SharedType> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::control_service::SharedType>() { + return ::control_service::SharedType_descriptor(); +} + +} // namespace protobuf +} // namespace google + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // control_5fservice_2ftypes_2eproto_2epb_2eh diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.cc new file mode 100644 index 0000000000..c685168899 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.cc @@ -0,0 +1,9 @@ +#include "usecases/cs/lpc/messages.grpc-ext.pb.h" + +#include +#include + +namespace cs_lpc { + +} // namespace cs_lpc + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.h new file mode 100644 index 0000000000..250ac282a9 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.h @@ -0,0 +1,11 @@ +#ifndef GENERATED_usecases_cs_lpc_messages_proto_EXT_H +#define GENERATED_usecases_cs_lpc_messages_proto_EXT_H + +#include "usecases/cs/lpc/messages.grpc.pb.h" +#include "common_types/types.grpc-ext.pb.h" + +namespace cs_lpc { + +} // namespace cs_lpc + +#endif // GENERATED_usecases_cs_lpc_messages_proto_EXT_H diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.cc new file mode 100644 index 0000000000..ea69b97dc2 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.cc @@ -0,0 +1,25 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: usecases/cs/lpc/messages.proto + +#include "usecases/cs/lpc/messages.pb.h" +#include "usecases/cs/lpc/messages.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace cs_lpc { + +} // namespace cs_lpc + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.h new file mode 100644 index 0000000000..04f3369196 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.h @@ -0,0 +1,39 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: usecases/cs/lpc/messages.proto +// Original file comments: +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +// +#ifndef GRPC_usecases_2fcs_2flpc_2fmessages_2eproto__INCLUDED +#define GRPC_usecases_2fcs_2flpc_2fmessages_2eproto__INCLUDED + +#include "usecases/cs/lpc/messages.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace cs_lpc { + +} // namespace cs_lpc + + +#include +#endif // GRPC_usecases_2fcs_2flpc_2fmessages_2eproto__INCLUDED diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.cc new file mode 100644 index 0000000000..103f3f8470 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.cc @@ -0,0 +1,5425 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: usecases/cs/lpc/messages.proto +// Protobuf C++ Version: 5.29.0 + +#include "usecases/cs/lpc/messages.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace cs_lpc { + template +PROTOBUF_CONSTEXPR StopHeartbeatResponse::StopHeartbeatResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct StopHeartbeatResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR StopHeartbeatResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StopHeartbeatResponseDefaultTypeInternal() {} + union { + StopHeartbeatResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StopHeartbeatResponseDefaultTypeInternal _StopHeartbeatResponse_default_instance_; + template +PROTOBUF_CONSTEXPR StopHeartbeatRequest::StopHeartbeatRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct StopHeartbeatRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR StopHeartbeatRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StopHeartbeatRequestDefaultTypeInternal() {} + union { + StopHeartbeatRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StopHeartbeatRequestDefaultTypeInternal _StopHeartbeatRequest_default_instance_; + template +PROTOBUF_CONSTEXPR StartHeartbeatResponse::StartHeartbeatResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct StartHeartbeatResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR StartHeartbeatResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StartHeartbeatResponseDefaultTypeInternal() {} + union { + StartHeartbeatResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StartHeartbeatResponseDefaultTypeInternal _StartHeartbeatResponse_default_instance_; + template +PROTOBUF_CONSTEXPR StartHeartbeatRequest::StartHeartbeatRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct StartHeartbeatRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR StartHeartbeatRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StartHeartbeatRequestDefaultTypeInternal() {} + union { + StartHeartbeatRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StartHeartbeatRequestDefaultTypeInternal _StartHeartbeatRequest_default_instance_; + template +PROTOBUF_CONSTEXPR SetFailsafeDurationMinimumResponse::SetFailsafeDurationMinimumResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct SetFailsafeDurationMinimumResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetFailsafeDurationMinimumResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetFailsafeDurationMinimumResponseDefaultTypeInternal() {} + union { + SetFailsafeDurationMinimumResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetFailsafeDurationMinimumResponseDefaultTypeInternal _SetFailsafeDurationMinimumResponse_default_instance_; + +inline constexpr SetFailsafeDurationMinimumRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : duration_nanoseconds_{::int64_t{0}}, + is_changeable_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SetFailsafeDurationMinimumRequest::SetFailsafeDurationMinimumRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetFailsafeDurationMinimumRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetFailsafeDurationMinimumRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetFailsafeDurationMinimumRequestDefaultTypeInternal() {} + union { + SetFailsafeDurationMinimumRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetFailsafeDurationMinimumRequestDefaultTypeInternal _SetFailsafeDurationMinimumRequest_default_instance_; + template +PROTOBUF_CONSTEXPR SetFailsafeConsumptionActivePowerLimitResponse::SetFailsafeConsumptionActivePowerLimitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct SetFailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetFailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetFailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal() {} + union { + SetFailsafeConsumptionActivePowerLimitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetFailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal _SetFailsafeConsumptionActivePowerLimitResponse_default_instance_; + +inline constexpr SetFailsafeConsumptionActivePowerLimitRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : value_{0}, + is_changeable_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SetFailsafeConsumptionActivePowerLimitRequest::SetFailsafeConsumptionActivePowerLimitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetFailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetFailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetFailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal() {} + union { + SetFailsafeConsumptionActivePowerLimitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetFailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal _SetFailsafeConsumptionActivePowerLimitRequest_default_instance_; + template +PROTOBUF_CONSTEXPR SetConsumptionNominalMaxResponse::SetConsumptionNominalMaxResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct SetConsumptionNominalMaxResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetConsumptionNominalMaxResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetConsumptionNominalMaxResponseDefaultTypeInternal() {} + union { + SetConsumptionNominalMaxResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetConsumptionNominalMaxResponseDefaultTypeInternal _SetConsumptionNominalMaxResponse_default_instance_; + +inline constexpr SetConsumptionNominalMaxRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : value_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SetConsumptionNominalMaxRequest::SetConsumptionNominalMaxRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetConsumptionNominalMaxRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetConsumptionNominalMaxRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetConsumptionNominalMaxRequestDefaultTypeInternal() {} + union { + SetConsumptionNominalMaxRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetConsumptionNominalMaxRequestDefaultTypeInternal _SetConsumptionNominalMaxRequest_default_instance_; + template +PROTOBUF_CONSTEXPR SetConsumptionLimitResponse::SetConsumptionLimitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct SetConsumptionLimitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetConsumptionLimitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetConsumptionLimitResponseDefaultTypeInternal() {} + union { + SetConsumptionLimitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetConsumptionLimitResponseDefaultTypeInternal _SetConsumptionLimitResponse_default_instance_; + template +PROTOBUF_CONSTEXPR PendingConsumptionLimitRequest::PendingConsumptionLimitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct PendingConsumptionLimitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR PendingConsumptionLimitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PendingConsumptionLimitRequestDefaultTypeInternal() {} + union { + PendingConsumptionLimitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingConsumptionLimitRequestDefaultTypeInternal _PendingConsumptionLimitRequest_default_instance_; + +inline constexpr IsHeartbeatWithinDurationResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : is_within_duration_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR IsHeartbeatWithinDurationResponse::IsHeartbeatWithinDurationResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct IsHeartbeatWithinDurationResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR IsHeartbeatWithinDurationResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~IsHeartbeatWithinDurationResponseDefaultTypeInternal() {} + union { + IsHeartbeatWithinDurationResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IsHeartbeatWithinDurationResponseDefaultTypeInternal _IsHeartbeatWithinDurationResponse_default_instance_; + template +PROTOBUF_CONSTEXPR IsHeartbeatWithinDurationRequest::IsHeartbeatWithinDurationRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct IsHeartbeatWithinDurationRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR IsHeartbeatWithinDurationRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~IsHeartbeatWithinDurationRequestDefaultTypeInternal() {} + union { + IsHeartbeatWithinDurationRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IsHeartbeatWithinDurationRequestDefaultTypeInternal _IsHeartbeatWithinDurationRequest_default_instance_; + +inline constexpr FailsafeDurationMinimumResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : duration_nanoseconds_{::int64_t{0}}, + is_changeable_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR FailsafeDurationMinimumResponse::FailsafeDurationMinimumResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct FailsafeDurationMinimumResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR FailsafeDurationMinimumResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FailsafeDurationMinimumResponseDefaultTypeInternal() {} + union { + FailsafeDurationMinimumResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FailsafeDurationMinimumResponseDefaultTypeInternal _FailsafeDurationMinimumResponse_default_instance_; + template +PROTOBUF_CONSTEXPR FailsafeDurationMinimumRequest::FailsafeDurationMinimumRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct FailsafeDurationMinimumRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR FailsafeDurationMinimumRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FailsafeDurationMinimumRequestDefaultTypeInternal() {} + union { + FailsafeDurationMinimumRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FailsafeDurationMinimumRequestDefaultTypeInternal _FailsafeDurationMinimumRequest_default_instance_; + +inline constexpr FailsafeConsumptionActivePowerLimitResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : limit_{0}, + is_changeable_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR FailsafeConsumptionActivePowerLimitResponse::FailsafeConsumptionActivePowerLimitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct FailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR FailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal() {} + union { + FailsafeConsumptionActivePowerLimitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal _FailsafeConsumptionActivePowerLimitResponse_default_instance_; + template +PROTOBUF_CONSTEXPR FailsafeConsumptionActivePowerLimitRequest::FailsafeConsumptionActivePowerLimitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct FailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR FailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal() {} + union { + FailsafeConsumptionActivePowerLimitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal _FailsafeConsumptionActivePowerLimitRequest_default_instance_; + +inline constexpr ConsumptionNominalMaxResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : value_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ConsumptionNominalMaxResponse::ConsumptionNominalMaxResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ConsumptionNominalMaxResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ConsumptionNominalMaxResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ConsumptionNominalMaxResponseDefaultTypeInternal() {} + union { + ConsumptionNominalMaxResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConsumptionNominalMaxResponseDefaultTypeInternal _ConsumptionNominalMaxResponse_default_instance_; + template +PROTOBUF_CONSTEXPR ConsumptionNominalMaxRequest::ConsumptionNominalMaxRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct ConsumptionNominalMaxRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR ConsumptionNominalMaxRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ConsumptionNominalMaxRequestDefaultTypeInternal() {} + union { + ConsumptionNominalMaxRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConsumptionNominalMaxRequestDefaultTypeInternal _ConsumptionNominalMaxRequest_default_instance_; + template +PROTOBUF_CONSTEXPR ConsumptionLimitRequest::ConsumptionLimitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct ConsumptionLimitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR ConsumptionLimitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ConsumptionLimitRequestDefaultTypeInternal() {} + union { + ConsumptionLimitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConsumptionLimitRequestDefaultTypeInternal _ConsumptionLimitRequest_default_instance_; + template +PROTOBUF_CONSTEXPR ApproveOrDenyConsumptionLimitResponse::ApproveOrDenyConsumptionLimitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct ApproveOrDenyConsumptionLimitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ApproveOrDenyConsumptionLimitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ApproveOrDenyConsumptionLimitResponseDefaultTypeInternal() {} + union { + ApproveOrDenyConsumptionLimitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ApproveOrDenyConsumptionLimitResponseDefaultTypeInternal _ApproveOrDenyConsumptionLimitResponse_default_instance_; + +inline constexpr ApproveOrDenyConsumptionLimitRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : reason_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + msg_counter_{::uint64_t{0u}}, + approve_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ApproveOrDenyConsumptionLimitRequest::ApproveOrDenyConsumptionLimitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ApproveOrDenyConsumptionLimitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR ApproveOrDenyConsumptionLimitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ApproveOrDenyConsumptionLimitRequestDefaultTypeInternal() {} + union { + ApproveOrDenyConsumptionLimitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ApproveOrDenyConsumptionLimitRequestDefaultTypeInternal _ApproveOrDenyConsumptionLimitRequest_default_instance_; + +inline constexpr SetConsumptionLimitRequest::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + load_limit_{nullptr} {} + +template +PROTOBUF_CONSTEXPR SetConsumptionLimitRequest::SetConsumptionLimitRequest(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetConsumptionLimitRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetConsumptionLimitRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetConsumptionLimitRequestDefaultTypeInternal() {} + union { + SetConsumptionLimitRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetConsumptionLimitRequestDefaultTypeInternal _SetConsumptionLimitRequest_default_instance_; + template +PROTOBUF_CONSTEXPR PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::MapEntry(_class_data_.base()){} +#else // PROTOBUF_CUSTOM_VTABLE + : PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::MapEntry() { +} +#endif // PROTOBUF_CUSTOM_VTABLE +struct PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUseDefaultTypeInternal() {} + union { + PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUseDefaultTypeInternal _PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse_default_instance_; + +inline constexpr ConsumptionLimitResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + load_limit_{nullptr} {} + +template +PROTOBUF_CONSTEXPR ConsumptionLimitResponse::ConsumptionLimitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ConsumptionLimitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ConsumptionLimitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ConsumptionLimitResponseDefaultTypeInternal() {} + union { + ConsumptionLimitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConsumptionLimitResponseDefaultTypeInternal _ConsumptionLimitResponse_default_instance_; + +inline constexpr PendingConsumptionLimitResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : load_limits_{}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR PendingConsumptionLimitResponse::PendingConsumptionLimitResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct PendingConsumptionLimitResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR PendingConsumptionLimitResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PendingConsumptionLimitResponseDefaultTypeInternal() {} + union { + PendingConsumptionLimitResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingConsumptionLimitResponseDefaultTypeInternal _PendingConsumptionLimitResponse_default_instance_; +} // namespace cs_lpc +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_usecases_2fcs_2flpc_2fmessages_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_usecases_2fcs_2flpc_2fmessages_2eproto = nullptr; +const ::uint32_t + TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::ConsumptionLimitRequest, _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(::cs_lpc::ConsumptionLimitResponse, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::ConsumptionLimitResponse, _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(::cs_lpc::ConsumptionLimitResponse, _impl_.load_limit_), + 0, + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetConsumptionLimitRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetConsumptionLimitRequest, _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(::cs_lpc::SetConsumptionLimitRequest, _impl_.load_limit_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetConsumptionLimitResponse, _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(::cs_lpc::PendingConsumptionLimitRequest, _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(::cs_lpc::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::PendingConsumptionLimitResponse_LoadLimitsEntry_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(::cs_lpc::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::PendingConsumptionLimitResponse, _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(::cs_lpc::PendingConsumptionLimitResponse, _impl_.load_limits_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::ApproveOrDenyConsumptionLimitRequest, _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(::cs_lpc::ApproveOrDenyConsumptionLimitRequest, _impl_.msg_counter_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::ApproveOrDenyConsumptionLimitRequest, _impl_.approve_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::ApproveOrDenyConsumptionLimitRequest, _impl_.reason_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::ApproveOrDenyConsumptionLimitResponse, _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(::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, _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(::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, _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(::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, _impl_.limit_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, _impl_.is_changeable_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, _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(::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, _impl_.is_changeable_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse, _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(::cs_lpc::FailsafeDurationMinimumRequest, _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(::cs_lpc::FailsafeDurationMinimumResponse, _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(::cs_lpc::FailsafeDurationMinimumResponse, _impl_.duration_nanoseconds_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::FailsafeDurationMinimumResponse, _impl_.is_changeable_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetFailsafeDurationMinimumRequest, _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(::cs_lpc::SetFailsafeDurationMinimumRequest, _impl_.duration_nanoseconds_), + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetFailsafeDurationMinimumRequest, _impl_.is_changeable_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetFailsafeDurationMinimumResponse, _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(::cs_lpc::StartHeartbeatRequest, _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(::cs_lpc::StartHeartbeatResponse, _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(::cs_lpc::StopHeartbeatRequest, _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(::cs_lpc::StopHeartbeatResponse, _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(::cs_lpc::IsHeartbeatWithinDurationRequest, _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(::cs_lpc::IsHeartbeatWithinDurationResponse, _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(::cs_lpc::IsHeartbeatWithinDurationResponse, _impl_.is_within_duration_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::ConsumptionNominalMaxRequest, _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(::cs_lpc::ConsumptionNominalMaxResponse, _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(::cs_lpc::ConsumptionNominalMaxResponse, _impl_.value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetConsumptionNominalMaxRequest, _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(::cs_lpc::SetConsumptionNominalMaxRequest, _impl_.value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::cs_lpc::SetConsumptionNominalMaxResponse, _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) +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::cs_lpc::ConsumptionLimitRequest)}, + {8, 17, -1, sizeof(::cs_lpc::ConsumptionLimitResponse)}, + {18, 27, -1, sizeof(::cs_lpc::SetConsumptionLimitRequest)}, + {28, -1, -1, sizeof(::cs_lpc::SetConsumptionLimitResponse)}, + {36, -1, -1, sizeof(::cs_lpc::PendingConsumptionLimitRequest)}, + {44, 54, -1, sizeof(::cs_lpc::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse)}, + {56, -1, -1, sizeof(::cs_lpc::PendingConsumptionLimitResponse)}, + {65, -1, -1, sizeof(::cs_lpc::ApproveOrDenyConsumptionLimitRequest)}, + {76, -1, -1, sizeof(::cs_lpc::ApproveOrDenyConsumptionLimitResponse)}, + {84, -1, -1, sizeof(::cs_lpc::FailsafeConsumptionActivePowerLimitRequest)}, + {92, -1, -1, sizeof(::cs_lpc::FailsafeConsumptionActivePowerLimitResponse)}, + {102, -1, -1, sizeof(::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest)}, + {112, -1, -1, sizeof(::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse)}, + {120, -1, -1, sizeof(::cs_lpc::FailsafeDurationMinimumRequest)}, + {128, -1, -1, sizeof(::cs_lpc::FailsafeDurationMinimumResponse)}, + {138, -1, -1, sizeof(::cs_lpc::SetFailsafeDurationMinimumRequest)}, + {148, -1, -1, sizeof(::cs_lpc::SetFailsafeDurationMinimumResponse)}, + {156, -1, -1, sizeof(::cs_lpc::StartHeartbeatRequest)}, + {164, -1, -1, sizeof(::cs_lpc::StartHeartbeatResponse)}, + {172, -1, -1, sizeof(::cs_lpc::StopHeartbeatRequest)}, + {180, -1, -1, sizeof(::cs_lpc::StopHeartbeatResponse)}, + {188, -1, -1, sizeof(::cs_lpc::IsHeartbeatWithinDurationRequest)}, + {196, -1, -1, sizeof(::cs_lpc::IsHeartbeatWithinDurationResponse)}, + {205, -1, -1, sizeof(::cs_lpc::ConsumptionNominalMaxRequest)}, + {213, -1, -1, sizeof(::cs_lpc::ConsumptionNominalMaxResponse)}, + {222, -1, -1, sizeof(::cs_lpc::SetConsumptionNominalMaxRequest)}, + {231, -1, -1, sizeof(::cs_lpc::SetConsumptionNominalMaxResponse)}, +}; +static const ::_pb::Message* const file_default_instances[] = { + &::cs_lpc::_ConsumptionLimitRequest_default_instance_._instance, + &::cs_lpc::_ConsumptionLimitResponse_default_instance_._instance, + &::cs_lpc::_SetConsumptionLimitRequest_default_instance_._instance, + &::cs_lpc::_SetConsumptionLimitResponse_default_instance_._instance, + &::cs_lpc::_PendingConsumptionLimitRequest_default_instance_._instance, + &::cs_lpc::_PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse_default_instance_._instance, + &::cs_lpc::_PendingConsumptionLimitResponse_default_instance_._instance, + &::cs_lpc::_ApproveOrDenyConsumptionLimitRequest_default_instance_._instance, + &::cs_lpc::_ApproveOrDenyConsumptionLimitResponse_default_instance_._instance, + &::cs_lpc::_FailsafeConsumptionActivePowerLimitRequest_default_instance_._instance, + &::cs_lpc::_FailsafeConsumptionActivePowerLimitResponse_default_instance_._instance, + &::cs_lpc::_SetFailsafeConsumptionActivePowerLimitRequest_default_instance_._instance, + &::cs_lpc::_SetFailsafeConsumptionActivePowerLimitResponse_default_instance_._instance, + &::cs_lpc::_FailsafeDurationMinimumRequest_default_instance_._instance, + &::cs_lpc::_FailsafeDurationMinimumResponse_default_instance_._instance, + &::cs_lpc::_SetFailsafeDurationMinimumRequest_default_instance_._instance, + &::cs_lpc::_SetFailsafeDurationMinimumResponse_default_instance_._instance, + &::cs_lpc::_StartHeartbeatRequest_default_instance_._instance, + &::cs_lpc::_StartHeartbeatResponse_default_instance_._instance, + &::cs_lpc::_StopHeartbeatRequest_default_instance_._instance, + &::cs_lpc::_StopHeartbeatResponse_default_instance_._instance, + &::cs_lpc::_IsHeartbeatWithinDurationRequest_default_instance_._instance, + &::cs_lpc::_IsHeartbeatWithinDurationResponse_default_instance_._instance, + &::cs_lpc::_ConsumptionNominalMaxRequest_default_instance_._instance, + &::cs_lpc::_ConsumptionNominalMaxResponse_default_instance_._instance, + &::cs_lpc::_SetConsumptionNominalMaxRequest_default_instance_._instance, + &::cs_lpc::_SetConsumptionNominalMaxResponse_default_instance_._instance, +}; +const char descriptor_table_protodef_usecases_2fcs_2flpc_2fmessages_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\036usecases/cs/lpc/messages.proto\022\006cs_lpc" + "\032\030common_types/types.proto\"\031\n\027Consumptio" + "nLimitRequest\"G\n\030ConsumptionLimitRespons" + "e\022+\n\nload_limit\030\001 \001(\0132\027.common_types.Loa" + "dLimit\"I\n\032SetConsumptionLimitRequest\022+\n\n" + "load_limit\030\001 \001(\0132\027.common_types.LoadLimi" + "t\"\035\n\033SetConsumptionLimitResponse\" \n\036Pend" + "ingConsumptionLimitRequest\"\273\001\n\037PendingCo" + "nsumptionLimitResponse\022L\n\013load_limits\030\001 " + "\003(\01327.cs_lpc.PendingConsumptionLimitResp" + "onse.LoadLimitsEntry\032J\n\017LoadLimitsEntry\022" + "\013\n\003key\030\001 \001(\004\022&\n\005value\030\002 \001(\0132\027.common_typ" + "es.LoadLimit:\0028\001\"\\\n$ApproveOrDenyConsump" + "tionLimitRequest\022\023\n\013msg_counter\030\001 \001(\004\022\017\n" + "\007approve\030\002 \001(\010\022\016\n\006reason\030\003 \001(\t\"\'\n%Approv" + "eOrDenyConsumptionLimitResponse\",\n*Fails" + "afeConsumptionActivePowerLimitRequest\"S\n" + "+FailsafeConsumptionActivePowerLimitResp" + "onse\022\r\n\005limit\030\001 \001(\001\022\025\n\ris_changeable\030\002 \001" + "(\010\"U\n-SetFailsafeConsumptionActivePowerL" + "imitRequest\022\r\n\005value\030\001 \001(\001\022\025\n\ris_changea" + "ble\030\002 \001(\010\"0\n.SetFailsafeConsumptionActiv" + "ePowerLimitResponse\" \n\036FailsafeDurationM" + "inimumRequest\"V\n\037FailsafeDurationMinimum" + "Response\022\034\n\024duration_nanoseconds\030\001 \001(\003\022\025" + "\n\ris_changeable\030\002 \001(\010\"X\n!SetFailsafeDura" + "tionMinimumRequest\022\034\n\024duration_nanosecon" + "ds\030\001 \001(\003\022\025\n\ris_changeable\030\002 \001(\010\"$\n\"SetFa" + "ilsafeDurationMinimumResponse\"\027\n\025StartHe" + "artbeatRequest\"\030\n\026StartHeartbeatResponse" + "\"\026\n\024StopHeartbeatRequest\"\027\n\025StopHeartbea" + "tResponse\"\"\n IsHeartbeatWithinDurationRe" + "quest\"\?\n!IsHeartbeatWithinDurationRespon" + "se\022\032\n\022is_within_duration\030\001 \001(\010\"\036\n\034Consum" + "ptionNominalMaxRequest\".\n\035ConsumptionNom" + "inalMaxResponse\022\r\n\005value\030\001 \001(\001\"0\n\037SetCon" + "sumptionNominalMaxRequest\022\r\n\005value\030\001 \001(\001" + "\"\"\n SetConsumptionNominalMaxResponseB=Z;" + "github.com/enbility/eebus-grpc/rpc_servi" + "ces/usecases/cs/lpcb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto_deps[1] = + { + &::descriptor_table_common_5ftypes_2ftypes_2eproto, +}; +static ::absl::once_flag descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto_once; +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto = { + false, + false, + 1587, + descriptor_table_protodef_usecases_2fcs_2flpc_2fmessages_2eproto, + "usecases/cs/lpc/messages.proto", + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto_once, + descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto_deps, + 1, + 27, + schemas, + file_default_instances, + TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto::offsets, + file_level_enum_descriptors_usecases_2fcs_2flpc_2fmessages_2eproto, + file_level_service_descriptors_usecases_2fcs_2flpc_2fmessages_2eproto, +}; +namespace cs_lpc { +// =================================================================== + +class ConsumptionLimitRequest::_Internal { + public: +}; + +ConsumptionLimitRequest::ConsumptionLimitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.ConsumptionLimitRequest) +} +ConsumptionLimitRequest::ConsumptionLimitRequest( + ::google::protobuf::Arena* arena, + const ConsumptionLimitRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ConsumptionLimitRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.ConsumptionLimitRequest) +} + +inline void* ConsumptionLimitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ConsumptionLimitRequest(arena); +} +constexpr auto ConsumptionLimitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ConsumptionLimitRequest), + alignof(ConsumptionLimitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ConsumptionLimitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ConsumptionLimitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConsumptionLimitRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConsumptionLimitRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &ConsumptionLimitRequest::ByteSizeLong, + &ConsumptionLimitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConsumptionLimitRequest, _impl_._cached_size_), + false, + }, + &ConsumptionLimitRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ConsumptionLimitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ConsumptionLimitRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::ConsumptionLimitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata ConsumptionLimitRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ConsumptionLimitResponse::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ConsumptionLimitResponse, _impl_._has_bits_); +}; + +void ConsumptionLimitResponse::clear_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.load_limit_ != nullptr) _impl_.load_limit_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +ConsumptionLimitResponse::ConsumptionLimitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.ConsumptionLimitResponse) +} +inline PROTOBUF_NDEBUG_INLINE ConsumptionLimitResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::cs_lpc::ConsumptionLimitResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +ConsumptionLimitResponse::ConsumptionLimitResponse( + ::google::protobuf::Arena* arena, + const ConsumptionLimitResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ConsumptionLimitResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.load_limit_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::LoadLimit>( + arena, *from._impl_.load_limit_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:cs_lpc.ConsumptionLimitResponse) +} +inline PROTOBUF_NDEBUG_INLINE ConsumptionLimitResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ConsumptionLimitResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.load_limit_ = {}; +} +ConsumptionLimitResponse::~ConsumptionLimitResponse() { + // @@protoc_insertion_point(destructor:cs_lpc.ConsumptionLimitResponse) + SharedDtor(*this); +} +inline void ConsumptionLimitResponse::SharedDtor(MessageLite& self) { + ConsumptionLimitResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.load_limit_; + this_._impl_.~Impl_(); +} + +inline void* ConsumptionLimitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ConsumptionLimitResponse(arena); +} +constexpr auto ConsumptionLimitResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ConsumptionLimitResponse), + alignof(ConsumptionLimitResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ConsumptionLimitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ConsumptionLimitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConsumptionLimitResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConsumptionLimitResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ConsumptionLimitResponse::ByteSizeLong, + &ConsumptionLimitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConsumptionLimitResponse, _impl_._cached_size_), + false, + }, + &ConsumptionLimitResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ConsumptionLimitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> ConsumptionLimitResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ConsumptionLimitResponse, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::ConsumptionLimitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .common_types.LoadLimit load_limit = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(ConsumptionLimitResponse, _impl_.load_limit_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .common_types.LoadLimit load_limit = 1; + {PROTOBUF_FIELD_OFFSET(ConsumptionLimitResponse, _impl_.load_limit_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::LoadLimit>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void ConsumptionLimitResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.ConsumptionLimitResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.load_limit_ != nullptr); + _impl_.load_limit_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ConsumptionLimitResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ConsumptionLimitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ConsumptionLimitResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ConsumptionLimitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.ConsumptionLimitResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.LoadLimit load_limit = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.load_limit_, this_._impl_.load_limit_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.ConsumptionLimitResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ConsumptionLimitResponse::ByteSizeLong(const MessageLite& base) { + const ConsumptionLimitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ConsumptionLimitResponse::ByteSizeLong() const { + const ConsumptionLimitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.ConsumptionLimitResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // .common_types.LoadLimit load_limit = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.load_limit_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ConsumptionLimitResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.ConsumptionLimitResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.load_limit_ != nullptr); + if (_this->_impl_.load_limit_ == nullptr) { + _this->_impl_.load_limit_ = + ::google::protobuf::Message::CopyConstruct<::common_types::LoadLimit>(arena, *from._impl_.load_limit_); + } else { + _this->_impl_.load_limit_->MergeFrom(*from._impl_.load_limit_); + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ConsumptionLimitResponse::CopyFrom(const ConsumptionLimitResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.ConsumptionLimitResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ConsumptionLimitResponse::InternalSwap(ConsumptionLimitResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.load_limit_, other->_impl_.load_limit_); +} + +::google::protobuf::Metadata ConsumptionLimitResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetConsumptionLimitRequest::_Internal { + public: + using HasBits = + decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetConsumptionLimitRequest, _impl_._has_bits_); +}; + +void SetConsumptionLimitRequest::clear_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.load_limit_ != nullptr) _impl_.load_limit_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +SetConsumptionLimitRequest::SetConsumptionLimitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetConsumptionLimitRequest) +} +inline PROTOBUF_NDEBUG_INLINE SetConsumptionLimitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::cs_lpc::SetConsumptionLimitRequest& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +SetConsumptionLimitRequest::SetConsumptionLimitRequest( + ::google::protobuf::Arena* arena, + const SetConsumptionLimitRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetConsumptionLimitRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.load_limit_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::common_types::LoadLimit>( + arena, *from._impl_.load_limit_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:cs_lpc.SetConsumptionLimitRequest) +} +inline PROTOBUF_NDEBUG_INLINE SetConsumptionLimitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SetConsumptionLimitRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.load_limit_ = {}; +} +SetConsumptionLimitRequest::~SetConsumptionLimitRequest() { + // @@protoc_insertion_point(destructor:cs_lpc.SetConsumptionLimitRequest) + SharedDtor(*this); +} +inline void SetConsumptionLimitRequest::SharedDtor(MessageLite& self) { + SetConsumptionLimitRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.load_limit_; + this_._impl_.~Impl_(); +} + +inline void* SetConsumptionLimitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetConsumptionLimitRequest(arena); +} +constexpr auto SetConsumptionLimitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetConsumptionLimitRequest), + alignof(SetConsumptionLimitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetConsumptionLimitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetConsumptionLimitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetConsumptionLimitRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetConsumptionLimitRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetConsumptionLimitRequest::ByteSizeLong, + &SetConsumptionLimitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetConsumptionLimitRequest, _impl_._cached_size_), + false, + }, + &SetConsumptionLimitRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetConsumptionLimitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> SetConsumptionLimitRequest::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetConsumptionLimitRequest, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetConsumptionLimitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .common_types.LoadLimit load_limit = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(SetConsumptionLimitRequest, _impl_.load_limit_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .common_types.LoadLimit load_limit = 1; + {PROTOBUF_FIELD_OFFSET(SetConsumptionLimitRequest, _impl_.load_limit_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::LoadLimit>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void SetConsumptionLimitRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.SetConsumptionLimitRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.load_limit_ != nullptr); + _impl_.load_limit_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetConsumptionLimitRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetConsumptionLimitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetConsumptionLimitRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetConsumptionLimitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.SetConsumptionLimitRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .common_types.LoadLimit load_limit = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.load_limit_, this_._impl_.load_limit_->GetCachedSize(), target, + stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.SetConsumptionLimitRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetConsumptionLimitRequest::ByteSizeLong(const MessageLite& base) { + const SetConsumptionLimitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetConsumptionLimitRequest::ByteSizeLong() const { + const SetConsumptionLimitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.SetConsumptionLimitRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // .common_types.LoadLimit load_limit = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.load_limit_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SetConsumptionLimitRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.SetConsumptionLimitRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(from._impl_.load_limit_ != nullptr); + if (_this->_impl_.load_limit_ == nullptr) { + _this->_impl_.load_limit_ = + ::google::protobuf::Message::CopyConstruct<::common_types::LoadLimit>(arena, *from._impl_.load_limit_); + } else { + _this->_impl_.load_limit_->MergeFrom(*from._impl_.load_limit_); + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SetConsumptionLimitRequest::CopyFrom(const SetConsumptionLimitRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.SetConsumptionLimitRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetConsumptionLimitRequest::InternalSwap(SetConsumptionLimitRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.load_limit_, other->_impl_.load_limit_); +} + +::google::protobuf::Metadata SetConsumptionLimitRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetConsumptionLimitResponse::_Internal { + public: +}; + +SetConsumptionLimitResponse::SetConsumptionLimitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetConsumptionLimitResponse) +} +SetConsumptionLimitResponse::SetConsumptionLimitResponse( + ::google::protobuf::Arena* arena, + const SetConsumptionLimitResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetConsumptionLimitResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.SetConsumptionLimitResponse) +} + +inline void* SetConsumptionLimitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetConsumptionLimitResponse(arena); +} +constexpr auto SetConsumptionLimitResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetConsumptionLimitResponse), + alignof(SetConsumptionLimitResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetConsumptionLimitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetConsumptionLimitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetConsumptionLimitResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetConsumptionLimitResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &SetConsumptionLimitResponse::ByteSizeLong, + &SetConsumptionLimitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetConsumptionLimitResponse, _impl_._cached_size_), + false, + }, + &SetConsumptionLimitResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetConsumptionLimitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SetConsumptionLimitResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetConsumptionLimitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata SetConsumptionLimitResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class PendingConsumptionLimitRequest::_Internal { + public: +}; + +PendingConsumptionLimitRequest::PendingConsumptionLimitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.PendingConsumptionLimitRequest) +} +PendingConsumptionLimitRequest::PendingConsumptionLimitRequest( + ::google::protobuf::Arena* arena, + const PendingConsumptionLimitRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + PendingConsumptionLimitRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.PendingConsumptionLimitRequest) +} + +inline void* PendingConsumptionLimitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PendingConsumptionLimitRequest(arena); +} +constexpr auto PendingConsumptionLimitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PendingConsumptionLimitRequest), + alignof(PendingConsumptionLimitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull PendingConsumptionLimitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_PendingConsumptionLimitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PendingConsumptionLimitRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PendingConsumptionLimitRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &PendingConsumptionLimitRequest::ByteSizeLong, + &PendingConsumptionLimitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitRequest, _impl_._cached_size_), + false, + }, + &PendingConsumptionLimitRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* PendingConsumptionLimitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> PendingConsumptionLimitRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::PendingConsumptionLimitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata PendingConsumptionLimitRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +#if defined(PROTOBUF_CUSTOM_VTABLE) + PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse() : SuperType(_class_data_.base()) {} + PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse(::google::protobuf::Arena* arena) + : SuperType(arena, _class_data_.base()) {} +#else // PROTOBUF_CUSTOM_VTABLE + PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse() : SuperType() {} + PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse(::google::protobuf::Arena* arena) : SuperType(arena) {} +#endif // PROTOBUF_CUSTOM_VTABLE + inline void* PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse(arena); + } + constexpr auto PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse), + alignof(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse)); + } + PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 + const ::google::protobuf::internal::ClassDataFull PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), + #if defined(PROTOBUF_CUSTOM_VTABLE) + &PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::SharedDtor, + static_cast( + &PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::ClearImpl), + ::google::protobuf::Message::ByteSizeLongImpl, ::google::protobuf::Message::_InternalSerializeImpl + , + #endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_._cached_size_), + false, + }, + &PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker + }; + const ::google::protobuf::internal::ClassData* PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); + } +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse_LoadLimitsEntry_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 + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::DiscardEverythingFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .common_types.LoadLimit value = 2; + {::_pbi::TcParser::FastMtS1, + {18, 0, 0, PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.value_)}}, + // uint64 key = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.key_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.key_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint64 key = 1; + {PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.key_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // .common_types.LoadLimit value = 2; + {PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse, _impl_.value_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::common_types::LoadLimit>()}, + }}, {{ + }}, +}; + +// =================================================================== + +class PendingConsumptionLimitResponse::_Internal { + public: +}; + +void PendingConsumptionLimitResponse::clear_load_limits() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.load_limits_.Clear(); +} +PendingConsumptionLimitResponse::PendingConsumptionLimitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.PendingConsumptionLimitResponse) +} +inline PROTOBUF_NDEBUG_INLINE PendingConsumptionLimitResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::cs_lpc::PendingConsumptionLimitResponse& from_msg) + : load_limits_{visibility, arena, from.load_limits_}, + _cached_size_{0} {} + +PendingConsumptionLimitResponse::PendingConsumptionLimitResponse( + ::google::protobuf::Arena* arena, + const PendingConsumptionLimitResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + PendingConsumptionLimitResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.PendingConsumptionLimitResponse) +} +inline PROTOBUF_NDEBUG_INLINE PendingConsumptionLimitResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : load_limits_{visibility, arena}, + _cached_size_{0} {} + +inline void PendingConsumptionLimitResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +PendingConsumptionLimitResponse::~PendingConsumptionLimitResponse() { + // @@protoc_insertion_point(destructor:cs_lpc.PendingConsumptionLimitResponse) + SharedDtor(*this); +} +inline void PendingConsumptionLimitResponse::SharedDtor(MessageLite& self) { + PendingConsumptionLimitResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PendingConsumptionLimitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PendingConsumptionLimitResponse(arena); +} +constexpr auto PendingConsumptionLimitResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse, _impl_.load_limits_) + + decltype(PendingConsumptionLimitResponse::_impl_.load_limits_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse, _impl_.load_limits_) + + decltype(PendingConsumptionLimitResponse::_impl_.load_limits_):: + InternalGetArenaOffsetAlt( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(PendingConsumptionLimitResponse), alignof(PendingConsumptionLimitResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&PendingConsumptionLimitResponse::PlacementNew_, + sizeof(PendingConsumptionLimitResponse), + alignof(PendingConsumptionLimitResponse)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull PendingConsumptionLimitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_PendingConsumptionLimitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PendingConsumptionLimitResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PendingConsumptionLimitResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &PendingConsumptionLimitResponse::ByteSizeLong, + &PendingConsumptionLimitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse, _impl_._cached_size_), + false, + }, + &PendingConsumptionLimitResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* PendingConsumptionLimitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 2, 0, 2> PendingConsumptionLimitResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::PendingConsumptionLimitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // map load_limits = 1; + {PROTOBUF_FIELD_OFFSET(PendingConsumptionLimitResponse, _impl_.load_limits_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMap)}, + }}, {{ + {::_pbi::TcParser::GetMapAuxInfo< + decltype(PendingConsumptionLimitResponse()._impl_.load_limits_)>( + 0, 0, 0, 4, + 11)}, + {::_pbi::TcParser::GetTable<::common_types::LoadLimit>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void PendingConsumptionLimitResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.PendingConsumptionLimitResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.load_limits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* PendingConsumptionLimitResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const PendingConsumptionLimitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* PendingConsumptionLimitResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const PendingConsumptionLimitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.PendingConsumptionLimitResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // map load_limits = 1; + if (!this_._internal_load_limits().empty()) { + using MapType = ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>; + using WireHelper = _pbi::MapEntryFuncs<::uint64_t, ::common_types::LoadLimit, + _pbi::WireFormatLite::TYPE_UINT64, + _pbi::WireFormatLite::TYPE_MESSAGE>; + const auto& field = this_._internal_load_limits(); + + if (stream->IsSerializationDeterministic() && field.size() > 1) { + for (const auto& entry : ::google::protobuf::internal::MapSorterFlat(field)) { + target = WireHelper::InternalSerialize( + 1, entry.first, entry.second, target, stream); + } + } else { + for (const auto& entry : field) { + target = WireHelper::InternalSerialize( + 1, entry.first, entry.second, target, stream); + } + } + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.PendingConsumptionLimitResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t PendingConsumptionLimitResponse::ByteSizeLong(const MessageLite& base) { + const PendingConsumptionLimitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t PendingConsumptionLimitResponse::ByteSizeLong() const { + const PendingConsumptionLimitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.PendingConsumptionLimitResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // map load_limits = 1; + { + total_size += + 1 * ::google::protobuf::internal::FromIntSize(this_._internal_load_limits_size()); + for (const auto& entry : this_._internal_load_limits()) { + total_size += _pbi::MapEntryFuncs<::uint64_t, ::common_types::LoadLimit, + _pbi::WireFormatLite::TYPE_UINT64, + _pbi::WireFormatLite::TYPE_MESSAGE>::ByteSizeLong(entry.first, entry.second); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void PendingConsumptionLimitResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.PendingConsumptionLimitResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.load_limits_.MergeFrom(from._impl_.load_limits_); + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void PendingConsumptionLimitResponse::CopyFrom(const PendingConsumptionLimitResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.PendingConsumptionLimitResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void PendingConsumptionLimitResponse::InternalSwap(PendingConsumptionLimitResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.load_limits_.InternalSwap(&other->_impl_.load_limits_); +} + +::google::protobuf::Metadata PendingConsumptionLimitResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ApproveOrDenyConsumptionLimitRequest::_Internal { + public: +}; + +ApproveOrDenyConsumptionLimitRequest::ApproveOrDenyConsumptionLimitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.ApproveOrDenyConsumptionLimitRequest) +} +inline PROTOBUF_NDEBUG_INLINE ApproveOrDenyConsumptionLimitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& from_msg) + : reason_(arena, from.reason_), + _cached_size_{0} {} + +ApproveOrDenyConsumptionLimitRequest::ApproveOrDenyConsumptionLimitRequest( + ::google::protobuf::Arena* arena, + const ApproveOrDenyConsumptionLimitRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ApproveOrDenyConsumptionLimitRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, msg_counter_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, msg_counter_), + offsetof(Impl_, approve_) - + offsetof(Impl_, msg_counter_) + + sizeof(Impl_::approve_)); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.ApproveOrDenyConsumptionLimitRequest) +} +inline PROTOBUF_NDEBUG_INLINE ApproveOrDenyConsumptionLimitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : reason_(arena), + _cached_size_{0} {} + +inline void ApproveOrDenyConsumptionLimitRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, msg_counter_), + 0, + offsetof(Impl_, approve_) - + offsetof(Impl_, msg_counter_) + + sizeof(Impl_::approve_)); +} +ApproveOrDenyConsumptionLimitRequest::~ApproveOrDenyConsumptionLimitRequest() { + // @@protoc_insertion_point(destructor:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + SharedDtor(*this); +} +inline void ApproveOrDenyConsumptionLimitRequest::SharedDtor(MessageLite& self) { + ApproveOrDenyConsumptionLimitRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.reason_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ApproveOrDenyConsumptionLimitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ApproveOrDenyConsumptionLimitRequest(arena); +} +constexpr auto ApproveOrDenyConsumptionLimitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ApproveOrDenyConsumptionLimitRequest), + alignof(ApproveOrDenyConsumptionLimitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ApproveOrDenyConsumptionLimitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ApproveOrDenyConsumptionLimitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ApproveOrDenyConsumptionLimitRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ApproveOrDenyConsumptionLimitRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ApproveOrDenyConsumptionLimitRequest::ByteSizeLong, + &ApproveOrDenyConsumptionLimitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_._cached_size_), + false, + }, + &ApproveOrDenyConsumptionLimitRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ApproveOrDenyConsumptionLimitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 58, 2> ApproveOrDenyConsumptionLimitRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::ApproveOrDenyConsumptionLimitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint64 msg_counter = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ApproveOrDenyConsumptionLimitRequest, _impl_.msg_counter_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.msg_counter_)}}, + // bool approve = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.approve_)}}, + // string reason = 3; + {::_pbi::TcParser::FastUS1, + {26, 63, 0, PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.reason_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint64 msg_counter = 1; + {PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.msg_counter_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // bool approve = 2; + {PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.approve_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // string reason = 3; + {PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.reason_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\53\0\0\6\0\0\0\0" + "cs_lpc.ApproveOrDenyConsumptionLimitRequest" + "reason" + }}, +}; + +PROTOBUF_NOINLINE void ApproveOrDenyConsumptionLimitRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.reason_.ClearToEmpty(); + ::memset(&_impl_.msg_counter_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.approve_) - + reinterpret_cast(&_impl_.msg_counter_)) + sizeof(_impl_.approve_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ApproveOrDenyConsumptionLimitRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ApproveOrDenyConsumptionLimitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ApproveOrDenyConsumptionLimitRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ApproveOrDenyConsumptionLimitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint64 msg_counter = 1; + if (this_._internal_msg_counter() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 1, this_._internal_msg_counter(), target); + } + + // bool approve = 2; + if (this_._internal_approve() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_approve(), target); + } + + // string reason = 3; + if (!this_._internal_reason().empty()) { + const std::string& _s = this_._internal_reason(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "cs_lpc.ApproveOrDenyConsumptionLimitRequest.reason"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ApproveOrDenyConsumptionLimitRequest::ByteSizeLong(const MessageLite& base) { + const ApproveOrDenyConsumptionLimitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ApproveOrDenyConsumptionLimitRequest::ByteSizeLong() const { + const ApproveOrDenyConsumptionLimitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string reason = 3; + if (!this_._internal_reason().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_reason()); + } + // uint64 msg_counter = 1; + if (this_._internal_msg_counter() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_msg_counter()); + } + // bool approve = 2; + if (this_._internal_approve() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ApproveOrDenyConsumptionLimitRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_reason().empty()) { + _this->_internal_set_reason(from._internal_reason()); + } + if (from._internal_msg_counter() != 0) { + _this->_impl_.msg_counter_ = from._impl_.msg_counter_; + } + if (from._internal_approve() != 0) { + _this->_impl_.approve_ = from._impl_.approve_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ApproveOrDenyConsumptionLimitRequest::CopyFrom(const ApproveOrDenyConsumptionLimitRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ApproveOrDenyConsumptionLimitRequest::InternalSwap(ApproveOrDenyConsumptionLimitRequest* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.reason_, &other->_impl_.reason_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.approve_) + + sizeof(ApproveOrDenyConsumptionLimitRequest::_impl_.approve_) + - PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitRequest, _impl_.msg_counter_)>( + reinterpret_cast(&_impl_.msg_counter_), + reinterpret_cast(&other->_impl_.msg_counter_)); +} + +::google::protobuf::Metadata ApproveOrDenyConsumptionLimitRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ApproveOrDenyConsumptionLimitResponse::_Internal { + public: +}; + +ApproveOrDenyConsumptionLimitResponse::ApproveOrDenyConsumptionLimitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.ApproveOrDenyConsumptionLimitResponse) +} +ApproveOrDenyConsumptionLimitResponse::ApproveOrDenyConsumptionLimitResponse( + ::google::protobuf::Arena* arena, + const ApproveOrDenyConsumptionLimitResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ApproveOrDenyConsumptionLimitResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.ApproveOrDenyConsumptionLimitResponse) +} + +inline void* ApproveOrDenyConsumptionLimitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ApproveOrDenyConsumptionLimitResponse(arena); +} +constexpr auto ApproveOrDenyConsumptionLimitResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ApproveOrDenyConsumptionLimitResponse), + alignof(ApproveOrDenyConsumptionLimitResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ApproveOrDenyConsumptionLimitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ApproveOrDenyConsumptionLimitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ApproveOrDenyConsumptionLimitResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ApproveOrDenyConsumptionLimitResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &ApproveOrDenyConsumptionLimitResponse::ByteSizeLong, + &ApproveOrDenyConsumptionLimitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ApproveOrDenyConsumptionLimitResponse, _impl_._cached_size_), + false, + }, + &ApproveOrDenyConsumptionLimitResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ApproveOrDenyConsumptionLimitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ApproveOrDenyConsumptionLimitResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::ApproveOrDenyConsumptionLimitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata ApproveOrDenyConsumptionLimitResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class FailsafeConsumptionActivePowerLimitRequest::_Internal { + public: +}; + +FailsafeConsumptionActivePowerLimitRequest::FailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.FailsafeConsumptionActivePowerLimitRequest) +} +FailsafeConsumptionActivePowerLimitRequest::FailsafeConsumptionActivePowerLimitRequest( + ::google::protobuf::Arena* arena, + const FailsafeConsumptionActivePowerLimitRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + FailsafeConsumptionActivePowerLimitRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.FailsafeConsumptionActivePowerLimitRequest) +} + +inline void* FailsafeConsumptionActivePowerLimitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) FailsafeConsumptionActivePowerLimitRequest(arena); +} +constexpr auto FailsafeConsumptionActivePowerLimitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FailsafeConsumptionActivePowerLimitRequest), + alignof(FailsafeConsumptionActivePowerLimitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull FailsafeConsumptionActivePowerLimitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_FailsafeConsumptionActivePowerLimitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &FailsafeConsumptionActivePowerLimitRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &FailsafeConsumptionActivePowerLimitRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &FailsafeConsumptionActivePowerLimitRequest::ByteSizeLong, + &FailsafeConsumptionActivePowerLimitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitRequest, _impl_._cached_size_), + false, + }, + &FailsafeConsumptionActivePowerLimitRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* FailsafeConsumptionActivePowerLimitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> FailsafeConsumptionActivePowerLimitRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::FailsafeConsumptionActivePowerLimitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata FailsafeConsumptionActivePowerLimitRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class FailsafeConsumptionActivePowerLimitResponse::_Internal { + public: +}; + +FailsafeConsumptionActivePowerLimitResponse::FailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) +} +FailsafeConsumptionActivePowerLimitResponse::FailsafeConsumptionActivePowerLimitResponse( + ::google::protobuf::Arena* arena, const FailsafeConsumptionActivePowerLimitResponse& from) + : FailsafeConsumptionActivePowerLimitResponse(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE FailsafeConsumptionActivePowerLimitResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void FailsafeConsumptionActivePowerLimitResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, limit_), + 0, + offsetof(Impl_, is_changeable_) - + offsetof(Impl_, limit_) + + sizeof(Impl_::is_changeable_)); +} +FailsafeConsumptionActivePowerLimitResponse::~FailsafeConsumptionActivePowerLimitResponse() { + // @@protoc_insertion_point(destructor:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + SharedDtor(*this); +} +inline void FailsafeConsumptionActivePowerLimitResponse::SharedDtor(MessageLite& self) { + FailsafeConsumptionActivePowerLimitResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* FailsafeConsumptionActivePowerLimitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) FailsafeConsumptionActivePowerLimitResponse(arena); +} +constexpr auto FailsafeConsumptionActivePowerLimitResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FailsafeConsumptionActivePowerLimitResponse), + alignof(FailsafeConsumptionActivePowerLimitResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull FailsafeConsumptionActivePowerLimitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_FailsafeConsumptionActivePowerLimitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &FailsafeConsumptionActivePowerLimitResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &FailsafeConsumptionActivePowerLimitResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &FailsafeConsumptionActivePowerLimitResponse::ByteSizeLong, + &FailsafeConsumptionActivePowerLimitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_._cached_size_), + false, + }, + &FailsafeConsumptionActivePowerLimitResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* FailsafeConsumptionActivePowerLimitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> FailsafeConsumptionActivePowerLimitResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool is_changeable = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_.is_changeable_)}}, + // double limit = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_.limit_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // double limit = 1; + {PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_.limit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool is_changeable = 2; + {PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_.is_changeable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void FailsafeConsumptionActivePowerLimitResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.limit_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.is_changeable_) - + reinterpret_cast(&_impl_.limit_)) + sizeof(_impl_.is_changeable_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* FailsafeConsumptionActivePowerLimitResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const FailsafeConsumptionActivePowerLimitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* FailsafeConsumptionActivePowerLimitResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const FailsafeConsumptionActivePowerLimitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double limit = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_limit()) != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this_._internal_limit(), target); + } + + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_is_changeable(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t FailsafeConsumptionActivePowerLimitResponse::ByteSizeLong(const MessageLite& base) { + const FailsafeConsumptionActivePowerLimitResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t FailsafeConsumptionActivePowerLimitResponse::ByteSizeLong() const { + const FailsafeConsumptionActivePowerLimitResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // double limit = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_limit()) != 0) { + total_size += 9; + } + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void FailsafeConsumptionActivePowerLimitResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (::absl::bit_cast<::uint64_t>(from._internal_limit()) != 0) { + _this->_impl_.limit_ = from._impl_.limit_; + } + if (from._internal_is_changeable() != 0) { + _this->_impl_.is_changeable_ = from._impl_.is_changeable_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void FailsafeConsumptionActivePowerLimitResponse::CopyFrom(const FailsafeConsumptionActivePowerLimitResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void FailsafeConsumptionActivePowerLimitResponse::InternalSwap(FailsafeConsumptionActivePowerLimitResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_.is_changeable_) + + sizeof(FailsafeConsumptionActivePowerLimitResponse::_impl_.is_changeable_) + - PROTOBUF_FIELD_OFFSET(FailsafeConsumptionActivePowerLimitResponse, _impl_.limit_)>( + reinterpret_cast(&_impl_.limit_), + reinterpret_cast(&other->_impl_.limit_)); +} + +::google::protobuf::Metadata FailsafeConsumptionActivePowerLimitResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetFailsafeConsumptionActivePowerLimitRequest::_Internal { + public: +}; + +SetFailsafeConsumptionActivePowerLimitRequest::SetFailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) +} +SetFailsafeConsumptionActivePowerLimitRequest::SetFailsafeConsumptionActivePowerLimitRequest( + ::google::protobuf::Arena* arena, const SetFailsafeConsumptionActivePowerLimitRequest& from) + : SetFailsafeConsumptionActivePowerLimitRequest(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SetFailsafeConsumptionActivePowerLimitRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SetFailsafeConsumptionActivePowerLimitRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, value_), + 0, + offsetof(Impl_, is_changeable_) - + offsetof(Impl_, value_) + + sizeof(Impl_::is_changeable_)); +} +SetFailsafeConsumptionActivePowerLimitRequest::~SetFailsafeConsumptionActivePowerLimitRequest() { + // @@protoc_insertion_point(destructor:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + SharedDtor(*this); +} +inline void SetFailsafeConsumptionActivePowerLimitRequest::SharedDtor(MessageLite& self) { + SetFailsafeConsumptionActivePowerLimitRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SetFailsafeConsumptionActivePowerLimitRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetFailsafeConsumptionActivePowerLimitRequest(arena); +} +constexpr auto SetFailsafeConsumptionActivePowerLimitRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetFailsafeConsumptionActivePowerLimitRequest), + alignof(SetFailsafeConsumptionActivePowerLimitRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetFailsafeConsumptionActivePowerLimitRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetFailsafeConsumptionActivePowerLimitRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetFailsafeConsumptionActivePowerLimitRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetFailsafeConsumptionActivePowerLimitRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetFailsafeConsumptionActivePowerLimitRequest::ByteSizeLong, + &SetFailsafeConsumptionActivePowerLimitRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_._cached_size_), + false, + }, + &SetFailsafeConsumptionActivePowerLimitRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetFailsafeConsumptionActivePowerLimitRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> SetFailsafeConsumptionActivePowerLimitRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool is_changeable = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_.is_changeable_)}}, + // double value = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_.value_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // double value = 1; + {PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_.value_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // bool is_changeable = 2; + {PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_.is_changeable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SetFailsafeConsumptionActivePowerLimitRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.value_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.is_changeable_) - + reinterpret_cast(&_impl_.value_)) + sizeof(_impl_.is_changeable_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetFailsafeConsumptionActivePowerLimitRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetFailsafeConsumptionActivePowerLimitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetFailsafeConsumptionActivePowerLimitRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetFailsafeConsumptionActivePowerLimitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double value = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this_._internal_value(), target); + } + + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_is_changeable(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetFailsafeConsumptionActivePowerLimitRequest::ByteSizeLong(const MessageLite& base) { + const SetFailsafeConsumptionActivePowerLimitRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetFailsafeConsumptionActivePowerLimitRequest::ByteSizeLong() const { + const SetFailsafeConsumptionActivePowerLimitRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // double value = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + total_size += 9; + } + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SetFailsafeConsumptionActivePowerLimitRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (::absl::bit_cast<::uint64_t>(from._internal_value()) != 0) { + _this->_impl_.value_ = from._impl_.value_; + } + if (from._internal_is_changeable() != 0) { + _this->_impl_.is_changeable_ = from._impl_.is_changeable_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SetFailsafeConsumptionActivePowerLimitRequest::CopyFrom(const SetFailsafeConsumptionActivePowerLimitRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetFailsafeConsumptionActivePowerLimitRequest::InternalSwap(SetFailsafeConsumptionActivePowerLimitRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_.is_changeable_) + + sizeof(SetFailsafeConsumptionActivePowerLimitRequest::_impl_.is_changeable_) + - PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitRequest, _impl_.value_)>( + reinterpret_cast(&_impl_.value_), + reinterpret_cast(&other->_impl_.value_)); +} + +::google::protobuf::Metadata SetFailsafeConsumptionActivePowerLimitRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetFailsafeConsumptionActivePowerLimitResponse::_Internal { + public: +}; + +SetFailsafeConsumptionActivePowerLimitResponse::SetFailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetFailsafeConsumptionActivePowerLimitResponse) +} +SetFailsafeConsumptionActivePowerLimitResponse::SetFailsafeConsumptionActivePowerLimitResponse( + ::google::protobuf::Arena* arena, + const SetFailsafeConsumptionActivePowerLimitResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetFailsafeConsumptionActivePowerLimitResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.SetFailsafeConsumptionActivePowerLimitResponse) +} + +inline void* SetFailsafeConsumptionActivePowerLimitResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetFailsafeConsumptionActivePowerLimitResponse(arena); +} +constexpr auto SetFailsafeConsumptionActivePowerLimitResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetFailsafeConsumptionActivePowerLimitResponse), + alignof(SetFailsafeConsumptionActivePowerLimitResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetFailsafeConsumptionActivePowerLimitResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetFailsafeConsumptionActivePowerLimitResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetFailsafeConsumptionActivePowerLimitResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetFailsafeConsumptionActivePowerLimitResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &SetFailsafeConsumptionActivePowerLimitResponse::ByteSizeLong, + &SetFailsafeConsumptionActivePowerLimitResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetFailsafeConsumptionActivePowerLimitResponse, _impl_._cached_size_), + false, + }, + &SetFailsafeConsumptionActivePowerLimitResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetFailsafeConsumptionActivePowerLimitResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SetFailsafeConsumptionActivePowerLimitResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata SetFailsafeConsumptionActivePowerLimitResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class FailsafeDurationMinimumRequest::_Internal { + public: +}; + +FailsafeDurationMinimumRequest::FailsafeDurationMinimumRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.FailsafeDurationMinimumRequest) +} +FailsafeDurationMinimumRequest::FailsafeDurationMinimumRequest( + ::google::protobuf::Arena* arena, + const FailsafeDurationMinimumRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + FailsafeDurationMinimumRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.FailsafeDurationMinimumRequest) +} + +inline void* FailsafeDurationMinimumRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) FailsafeDurationMinimumRequest(arena); +} +constexpr auto FailsafeDurationMinimumRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FailsafeDurationMinimumRequest), + alignof(FailsafeDurationMinimumRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull FailsafeDurationMinimumRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_FailsafeDurationMinimumRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &FailsafeDurationMinimumRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &FailsafeDurationMinimumRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &FailsafeDurationMinimumRequest::ByteSizeLong, + &FailsafeDurationMinimumRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumRequest, _impl_._cached_size_), + false, + }, + &FailsafeDurationMinimumRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* FailsafeDurationMinimumRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> FailsafeDurationMinimumRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::FailsafeDurationMinimumRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata FailsafeDurationMinimumRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class FailsafeDurationMinimumResponse::_Internal { + public: +}; + +FailsafeDurationMinimumResponse::FailsafeDurationMinimumResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.FailsafeDurationMinimumResponse) +} +FailsafeDurationMinimumResponse::FailsafeDurationMinimumResponse( + ::google::protobuf::Arena* arena, const FailsafeDurationMinimumResponse& from) + : FailsafeDurationMinimumResponse(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE FailsafeDurationMinimumResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void FailsafeDurationMinimumResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, duration_nanoseconds_), + 0, + offsetof(Impl_, is_changeable_) - + offsetof(Impl_, duration_nanoseconds_) + + sizeof(Impl_::is_changeable_)); +} +FailsafeDurationMinimumResponse::~FailsafeDurationMinimumResponse() { + // @@protoc_insertion_point(destructor:cs_lpc.FailsafeDurationMinimumResponse) + SharedDtor(*this); +} +inline void FailsafeDurationMinimumResponse::SharedDtor(MessageLite& self) { + FailsafeDurationMinimumResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* FailsafeDurationMinimumResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) FailsafeDurationMinimumResponse(arena); +} +constexpr auto FailsafeDurationMinimumResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FailsafeDurationMinimumResponse), + alignof(FailsafeDurationMinimumResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull FailsafeDurationMinimumResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_FailsafeDurationMinimumResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &FailsafeDurationMinimumResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &FailsafeDurationMinimumResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &FailsafeDurationMinimumResponse::ByteSizeLong, + &FailsafeDurationMinimumResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_._cached_size_), + false, + }, + &FailsafeDurationMinimumResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* FailsafeDurationMinimumResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> FailsafeDurationMinimumResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::FailsafeDurationMinimumResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool is_changeable = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_.is_changeable_)}}, + // int64 duration_nanoseconds = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(FailsafeDurationMinimumResponse, _impl_.duration_nanoseconds_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_.duration_nanoseconds_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int64 duration_nanoseconds = 1; + {PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_.duration_nanoseconds_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // bool is_changeable = 2; + {PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_.is_changeable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void FailsafeDurationMinimumResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.FailsafeDurationMinimumResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.duration_nanoseconds_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.is_changeable_) - + reinterpret_cast(&_impl_.duration_nanoseconds_)) + sizeof(_impl_.is_changeable_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* FailsafeDurationMinimumResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const FailsafeDurationMinimumResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* FailsafeDurationMinimumResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const FailsafeDurationMinimumResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.FailsafeDurationMinimumResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int64 duration_nanoseconds = 1; + if (this_._internal_duration_nanoseconds() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<1>( + stream, this_._internal_duration_nanoseconds(), target); + } + + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_is_changeable(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.FailsafeDurationMinimumResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t FailsafeDurationMinimumResponse::ByteSizeLong(const MessageLite& base) { + const FailsafeDurationMinimumResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t FailsafeDurationMinimumResponse::ByteSizeLong() const { + const FailsafeDurationMinimumResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.FailsafeDurationMinimumResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // int64 duration_nanoseconds = 1; + if (this_._internal_duration_nanoseconds() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_duration_nanoseconds()); + } + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void FailsafeDurationMinimumResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.FailsafeDurationMinimumResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_duration_nanoseconds() != 0) { + _this->_impl_.duration_nanoseconds_ = from._impl_.duration_nanoseconds_; + } + if (from._internal_is_changeable() != 0) { + _this->_impl_.is_changeable_ = from._impl_.is_changeable_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void FailsafeDurationMinimumResponse::CopyFrom(const FailsafeDurationMinimumResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.FailsafeDurationMinimumResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void FailsafeDurationMinimumResponse::InternalSwap(FailsafeDurationMinimumResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_.is_changeable_) + + sizeof(FailsafeDurationMinimumResponse::_impl_.is_changeable_) + - PROTOBUF_FIELD_OFFSET(FailsafeDurationMinimumResponse, _impl_.duration_nanoseconds_)>( + reinterpret_cast(&_impl_.duration_nanoseconds_), + reinterpret_cast(&other->_impl_.duration_nanoseconds_)); +} + +::google::protobuf::Metadata FailsafeDurationMinimumResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetFailsafeDurationMinimumRequest::_Internal { + public: +}; + +SetFailsafeDurationMinimumRequest::SetFailsafeDurationMinimumRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetFailsafeDurationMinimumRequest) +} +SetFailsafeDurationMinimumRequest::SetFailsafeDurationMinimumRequest( + ::google::protobuf::Arena* arena, const SetFailsafeDurationMinimumRequest& from) + : SetFailsafeDurationMinimumRequest(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SetFailsafeDurationMinimumRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SetFailsafeDurationMinimumRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, duration_nanoseconds_), + 0, + offsetof(Impl_, is_changeable_) - + offsetof(Impl_, duration_nanoseconds_) + + sizeof(Impl_::is_changeable_)); +} +SetFailsafeDurationMinimumRequest::~SetFailsafeDurationMinimumRequest() { + // @@protoc_insertion_point(destructor:cs_lpc.SetFailsafeDurationMinimumRequest) + SharedDtor(*this); +} +inline void SetFailsafeDurationMinimumRequest::SharedDtor(MessageLite& self) { + SetFailsafeDurationMinimumRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SetFailsafeDurationMinimumRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetFailsafeDurationMinimumRequest(arena); +} +constexpr auto SetFailsafeDurationMinimumRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetFailsafeDurationMinimumRequest), + alignof(SetFailsafeDurationMinimumRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetFailsafeDurationMinimumRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetFailsafeDurationMinimumRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetFailsafeDurationMinimumRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetFailsafeDurationMinimumRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetFailsafeDurationMinimumRequest::ByteSizeLong, + &SetFailsafeDurationMinimumRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_._cached_size_), + false, + }, + &SetFailsafeDurationMinimumRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetFailsafeDurationMinimumRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> SetFailsafeDurationMinimumRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetFailsafeDurationMinimumRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool is_changeable = 2; + {::_pbi::TcParser::SingularVarintNoZag1(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_.is_changeable_)}}, + // int64 duration_nanoseconds = 1; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SetFailsafeDurationMinimumRequest, _impl_.duration_nanoseconds_), 63>(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_.duration_nanoseconds_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // int64 duration_nanoseconds = 1; + {PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_.duration_nanoseconds_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, + // bool is_changeable = 2; + {PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_.is_changeable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SetFailsafeDurationMinimumRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.SetFailsafeDurationMinimumRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.duration_nanoseconds_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.is_changeable_) - + reinterpret_cast(&_impl_.duration_nanoseconds_)) + sizeof(_impl_.is_changeable_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetFailsafeDurationMinimumRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetFailsafeDurationMinimumRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetFailsafeDurationMinimumRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetFailsafeDurationMinimumRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.SetFailsafeDurationMinimumRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int64 duration_nanoseconds = 1; + if (this_._internal_duration_nanoseconds() != 0) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArrayWithField<1>( + stream, this_._internal_duration_nanoseconds(), target); + } + + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_is_changeable(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.SetFailsafeDurationMinimumRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetFailsafeDurationMinimumRequest::ByteSizeLong(const MessageLite& base) { + const SetFailsafeDurationMinimumRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetFailsafeDurationMinimumRequest::ByteSizeLong() const { + const SetFailsafeDurationMinimumRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.SetFailsafeDurationMinimumRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // int64 duration_nanoseconds = 1; + if (this_._internal_duration_nanoseconds() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_duration_nanoseconds()); + } + // bool is_changeable = 2; + if (this_._internal_is_changeable() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SetFailsafeDurationMinimumRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.SetFailsafeDurationMinimumRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_duration_nanoseconds() != 0) { + _this->_impl_.duration_nanoseconds_ = from._impl_.duration_nanoseconds_; + } + if (from._internal_is_changeable() != 0) { + _this->_impl_.is_changeable_ = from._impl_.is_changeable_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SetFailsafeDurationMinimumRequest::CopyFrom(const SetFailsafeDurationMinimumRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.SetFailsafeDurationMinimumRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetFailsafeDurationMinimumRequest::InternalSwap(SetFailsafeDurationMinimumRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_.is_changeable_) + + sizeof(SetFailsafeDurationMinimumRequest::_impl_.is_changeable_) + - PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumRequest, _impl_.duration_nanoseconds_)>( + reinterpret_cast(&_impl_.duration_nanoseconds_), + reinterpret_cast(&other->_impl_.duration_nanoseconds_)); +} + +::google::protobuf::Metadata SetFailsafeDurationMinimumRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetFailsafeDurationMinimumResponse::_Internal { + public: +}; + +SetFailsafeDurationMinimumResponse::SetFailsafeDurationMinimumResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetFailsafeDurationMinimumResponse) +} +SetFailsafeDurationMinimumResponse::SetFailsafeDurationMinimumResponse( + ::google::protobuf::Arena* arena, + const SetFailsafeDurationMinimumResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetFailsafeDurationMinimumResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.SetFailsafeDurationMinimumResponse) +} + +inline void* SetFailsafeDurationMinimumResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetFailsafeDurationMinimumResponse(arena); +} +constexpr auto SetFailsafeDurationMinimumResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetFailsafeDurationMinimumResponse), + alignof(SetFailsafeDurationMinimumResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetFailsafeDurationMinimumResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetFailsafeDurationMinimumResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetFailsafeDurationMinimumResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetFailsafeDurationMinimumResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &SetFailsafeDurationMinimumResponse::ByteSizeLong, + &SetFailsafeDurationMinimumResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetFailsafeDurationMinimumResponse, _impl_._cached_size_), + false, + }, + &SetFailsafeDurationMinimumResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetFailsafeDurationMinimumResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SetFailsafeDurationMinimumResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetFailsafeDurationMinimumResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata SetFailsafeDurationMinimumResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class StartHeartbeatRequest::_Internal { + public: +}; + +StartHeartbeatRequest::StartHeartbeatRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.StartHeartbeatRequest) +} +StartHeartbeatRequest::StartHeartbeatRequest( + ::google::protobuf::Arena* arena, + const StartHeartbeatRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + StartHeartbeatRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.StartHeartbeatRequest) +} + +inline void* StartHeartbeatRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) StartHeartbeatRequest(arena); +} +constexpr auto StartHeartbeatRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(StartHeartbeatRequest), + alignof(StartHeartbeatRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull StartHeartbeatRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_StartHeartbeatRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StartHeartbeatRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StartHeartbeatRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &StartHeartbeatRequest::ByteSizeLong, + &StartHeartbeatRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StartHeartbeatRequest, _impl_._cached_size_), + false, + }, + &StartHeartbeatRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* StartHeartbeatRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> StartHeartbeatRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::StartHeartbeatRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata StartHeartbeatRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class StartHeartbeatResponse::_Internal { + public: +}; + +StartHeartbeatResponse::StartHeartbeatResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.StartHeartbeatResponse) +} +StartHeartbeatResponse::StartHeartbeatResponse( + ::google::protobuf::Arena* arena, + const StartHeartbeatResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + StartHeartbeatResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.StartHeartbeatResponse) +} + +inline void* StartHeartbeatResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) StartHeartbeatResponse(arena); +} +constexpr auto StartHeartbeatResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(StartHeartbeatResponse), + alignof(StartHeartbeatResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull StartHeartbeatResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_StartHeartbeatResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StartHeartbeatResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StartHeartbeatResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &StartHeartbeatResponse::ByteSizeLong, + &StartHeartbeatResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StartHeartbeatResponse, _impl_._cached_size_), + false, + }, + &StartHeartbeatResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* StartHeartbeatResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> StartHeartbeatResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::StartHeartbeatResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata StartHeartbeatResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class StopHeartbeatRequest::_Internal { + public: +}; + +StopHeartbeatRequest::StopHeartbeatRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.StopHeartbeatRequest) +} +StopHeartbeatRequest::StopHeartbeatRequest( + ::google::protobuf::Arena* arena, + const StopHeartbeatRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + StopHeartbeatRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.StopHeartbeatRequest) +} + +inline void* StopHeartbeatRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) StopHeartbeatRequest(arena); +} +constexpr auto StopHeartbeatRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(StopHeartbeatRequest), + alignof(StopHeartbeatRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull StopHeartbeatRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_StopHeartbeatRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StopHeartbeatRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StopHeartbeatRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &StopHeartbeatRequest::ByteSizeLong, + &StopHeartbeatRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StopHeartbeatRequest, _impl_._cached_size_), + false, + }, + &StopHeartbeatRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* StopHeartbeatRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> StopHeartbeatRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::StopHeartbeatRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata StopHeartbeatRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class StopHeartbeatResponse::_Internal { + public: +}; + +StopHeartbeatResponse::StopHeartbeatResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.StopHeartbeatResponse) +} +StopHeartbeatResponse::StopHeartbeatResponse( + ::google::protobuf::Arena* arena, + const StopHeartbeatResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + StopHeartbeatResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.StopHeartbeatResponse) +} + +inline void* StopHeartbeatResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) StopHeartbeatResponse(arena); +} +constexpr auto StopHeartbeatResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(StopHeartbeatResponse), + alignof(StopHeartbeatResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull StopHeartbeatResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_StopHeartbeatResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &StopHeartbeatResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &StopHeartbeatResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &StopHeartbeatResponse::ByteSizeLong, + &StopHeartbeatResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(StopHeartbeatResponse, _impl_._cached_size_), + false, + }, + &StopHeartbeatResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* StopHeartbeatResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> StopHeartbeatResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::StopHeartbeatResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata StopHeartbeatResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class IsHeartbeatWithinDurationRequest::_Internal { + public: +}; + +IsHeartbeatWithinDurationRequest::IsHeartbeatWithinDurationRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.IsHeartbeatWithinDurationRequest) +} +IsHeartbeatWithinDurationRequest::IsHeartbeatWithinDurationRequest( + ::google::protobuf::Arena* arena, + const IsHeartbeatWithinDurationRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + IsHeartbeatWithinDurationRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.IsHeartbeatWithinDurationRequest) +} + +inline void* IsHeartbeatWithinDurationRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) IsHeartbeatWithinDurationRequest(arena); +} +constexpr auto IsHeartbeatWithinDurationRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IsHeartbeatWithinDurationRequest), + alignof(IsHeartbeatWithinDurationRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull IsHeartbeatWithinDurationRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_IsHeartbeatWithinDurationRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IsHeartbeatWithinDurationRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IsHeartbeatWithinDurationRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &IsHeartbeatWithinDurationRequest::ByteSizeLong, + &IsHeartbeatWithinDurationRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IsHeartbeatWithinDurationRequest, _impl_._cached_size_), + false, + }, + &IsHeartbeatWithinDurationRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* IsHeartbeatWithinDurationRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> IsHeartbeatWithinDurationRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::IsHeartbeatWithinDurationRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata IsHeartbeatWithinDurationRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class IsHeartbeatWithinDurationResponse::_Internal { + public: +}; + +IsHeartbeatWithinDurationResponse::IsHeartbeatWithinDurationResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.IsHeartbeatWithinDurationResponse) +} +IsHeartbeatWithinDurationResponse::IsHeartbeatWithinDurationResponse( + ::google::protobuf::Arena* arena, const IsHeartbeatWithinDurationResponse& from) + : IsHeartbeatWithinDurationResponse(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE IsHeartbeatWithinDurationResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void IsHeartbeatWithinDurationResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.is_within_duration_ = {}; +} +IsHeartbeatWithinDurationResponse::~IsHeartbeatWithinDurationResponse() { + // @@protoc_insertion_point(destructor:cs_lpc.IsHeartbeatWithinDurationResponse) + SharedDtor(*this); +} +inline void IsHeartbeatWithinDurationResponse::SharedDtor(MessageLite& self) { + IsHeartbeatWithinDurationResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* IsHeartbeatWithinDurationResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) IsHeartbeatWithinDurationResponse(arena); +} +constexpr auto IsHeartbeatWithinDurationResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IsHeartbeatWithinDurationResponse), + alignof(IsHeartbeatWithinDurationResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull IsHeartbeatWithinDurationResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_IsHeartbeatWithinDurationResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IsHeartbeatWithinDurationResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IsHeartbeatWithinDurationResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &IsHeartbeatWithinDurationResponse::ByteSizeLong, + &IsHeartbeatWithinDurationResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IsHeartbeatWithinDurationResponse, _impl_._cached_size_), + false, + }, + &IsHeartbeatWithinDurationResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* IsHeartbeatWithinDurationResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IsHeartbeatWithinDurationResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::IsHeartbeatWithinDurationResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // bool is_within_duration = 1; + {::_pbi::TcParser::SingularVarintNoZag1(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(IsHeartbeatWithinDurationResponse, _impl_.is_within_duration_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool is_within_duration = 1; + {PROTOBUF_FIELD_OFFSET(IsHeartbeatWithinDurationResponse, _impl_.is_within_duration_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void IsHeartbeatWithinDurationResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.IsHeartbeatWithinDurationResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.is_within_duration_ = false; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* IsHeartbeatWithinDurationResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const IsHeartbeatWithinDurationResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* IsHeartbeatWithinDurationResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const IsHeartbeatWithinDurationResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.IsHeartbeatWithinDurationResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // bool is_within_duration = 1; + if (this_._internal_is_within_duration() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this_._internal_is_within_duration(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.IsHeartbeatWithinDurationResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t IsHeartbeatWithinDurationResponse::ByteSizeLong(const MessageLite& base) { + const IsHeartbeatWithinDurationResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t IsHeartbeatWithinDurationResponse::ByteSizeLong() const { + const IsHeartbeatWithinDurationResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.IsHeartbeatWithinDurationResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // bool is_within_duration = 1; + if (this_._internal_is_within_duration() != 0) { + total_size += 2; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void IsHeartbeatWithinDurationResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.IsHeartbeatWithinDurationResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_is_within_duration() != 0) { + _this->_impl_.is_within_duration_ = from._impl_.is_within_duration_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void IsHeartbeatWithinDurationResponse::CopyFrom(const IsHeartbeatWithinDurationResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.IsHeartbeatWithinDurationResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void IsHeartbeatWithinDurationResponse::InternalSwap(IsHeartbeatWithinDurationResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.is_within_duration_, other->_impl_.is_within_duration_); +} + +::google::protobuf::Metadata IsHeartbeatWithinDurationResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ConsumptionNominalMaxRequest::_Internal { + public: +}; + +ConsumptionNominalMaxRequest::ConsumptionNominalMaxRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.ConsumptionNominalMaxRequest) +} +ConsumptionNominalMaxRequest::ConsumptionNominalMaxRequest( + ::google::protobuf::Arena* arena, + const ConsumptionNominalMaxRequest& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ConsumptionNominalMaxRequest* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.ConsumptionNominalMaxRequest) +} + +inline void* ConsumptionNominalMaxRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ConsumptionNominalMaxRequest(arena); +} +constexpr auto ConsumptionNominalMaxRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ConsumptionNominalMaxRequest), + alignof(ConsumptionNominalMaxRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ConsumptionNominalMaxRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ConsumptionNominalMaxRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConsumptionNominalMaxRequest::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConsumptionNominalMaxRequest::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &ConsumptionNominalMaxRequest::ByteSizeLong, + &ConsumptionNominalMaxRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConsumptionNominalMaxRequest, _impl_._cached_size_), + false, + }, + &ConsumptionNominalMaxRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ConsumptionNominalMaxRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ConsumptionNominalMaxRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::ConsumptionNominalMaxRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata ConsumptionNominalMaxRequest::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ConsumptionNominalMaxResponse::_Internal { + public: +}; + +ConsumptionNominalMaxResponse::ConsumptionNominalMaxResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.ConsumptionNominalMaxResponse) +} +ConsumptionNominalMaxResponse::ConsumptionNominalMaxResponse( + ::google::protobuf::Arena* arena, const ConsumptionNominalMaxResponse& from) + : ConsumptionNominalMaxResponse(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ConsumptionNominalMaxResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ConsumptionNominalMaxResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.value_ = {}; +} +ConsumptionNominalMaxResponse::~ConsumptionNominalMaxResponse() { + // @@protoc_insertion_point(destructor:cs_lpc.ConsumptionNominalMaxResponse) + SharedDtor(*this); +} +inline void ConsumptionNominalMaxResponse::SharedDtor(MessageLite& self) { + ConsumptionNominalMaxResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ConsumptionNominalMaxResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ConsumptionNominalMaxResponse(arena); +} +constexpr auto ConsumptionNominalMaxResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ConsumptionNominalMaxResponse), + alignof(ConsumptionNominalMaxResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull ConsumptionNominalMaxResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_ConsumptionNominalMaxResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ConsumptionNominalMaxResponse::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ConsumptionNominalMaxResponse::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ConsumptionNominalMaxResponse::ByteSizeLong, + &ConsumptionNominalMaxResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ConsumptionNominalMaxResponse, _impl_._cached_size_), + false, + }, + &ConsumptionNominalMaxResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* ConsumptionNominalMaxResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> ConsumptionNominalMaxResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::ConsumptionNominalMaxResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // double value = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(ConsumptionNominalMaxResponse, _impl_.value_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // double value = 1; + {PROTOBUF_FIELD_OFFSET(ConsumptionNominalMaxResponse, _impl_.value_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ConsumptionNominalMaxResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.ConsumptionNominalMaxResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.value_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ConsumptionNominalMaxResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ConsumptionNominalMaxResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ConsumptionNominalMaxResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ConsumptionNominalMaxResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.ConsumptionNominalMaxResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double value = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this_._internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.ConsumptionNominalMaxResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ConsumptionNominalMaxResponse::ByteSizeLong(const MessageLite& base) { + const ConsumptionNominalMaxResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ConsumptionNominalMaxResponse::ByteSizeLong() const { + const ConsumptionNominalMaxResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.ConsumptionNominalMaxResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // double value = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + total_size += 9; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void ConsumptionNominalMaxResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.ConsumptionNominalMaxResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (::absl::bit_cast<::uint64_t>(from._internal_value()) != 0) { + _this->_impl_.value_ = from._impl_.value_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void ConsumptionNominalMaxResponse::CopyFrom(const ConsumptionNominalMaxResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.ConsumptionNominalMaxResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ConsumptionNominalMaxResponse::InternalSwap(ConsumptionNominalMaxResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.value_, other->_impl_.value_); +} + +::google::protobuf::Metadata ConsumptionNominalMaxResponse::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetConsumptionNominalMaxRequest::_Internal { + public: +}; + +SetConsumptionNominalMaxRequest::SetConsumptionNominalMaxRequest(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetConsumptionNominalMaxRequest) +} +SetConsumptionNominalMaxRequest::SetConsumptionNominalMaxRequest( + ::google::protobuf::Arena* arena, const SetConsumptionNominalMaxRequest& from) + : SetConsumptionNominalMaxRequest(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SetConsumptionNominalMaxRequest::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SetConsumptionNominalMaxRequest::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.value_ = {}; +} +SetConsumptionNominalMaxRequest::~SetConsumptionNominalMaxRequest() { + // @@protoc_insertion_point(destructor:cs_lpc.SetConsumptionNominalMaxRequest) + SharedDtor(*this); +} +inline void SetConsumptionNominalMaxRequest::SharedDtor(MessageLite& self) { + SetConsumptionNominalMaxRequest& this_ = static_cast(self); + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SetConsumptionNominalMaxRequest::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetConsumptionNominalMaxRequest(arena); +} +constexpr auto SetConsumptionNominalMaxRequest::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetConsumptionNominalMaxRequest), + alignof(SetConsumptionNominalMaxRequest)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetConsumptionNominalMaxRequest::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetConsumptionNominalMaxRequest_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetConsumptionNominalMaxRequest::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetConsumptionNominalMaxRequest::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetConsumptionNominalMaxRequest::ByteSizeLong, + &SetConsumptionNominalMaxRequest::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetConsumptionNominalMaxRequest, _impl_._cached_size_), + false, + }, + &SetConsumptionNominalMaxRequest::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetConsumptionNominalMaxRequest::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SetConsumptionNominalMaxRequest::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetConsumptionNominalMaxRequest>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // double value = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(SetConsumptionNominalMaxRequest, _impl_.value_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // double value = 1; + {PROTOBUF_FIELD_OFFSET(SetConsumptionNominalMaxRequest, _impl_.value_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SetConsumptionNominalMaxRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cs_lpc.SetConsumptionNominalMaxRequest) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.value_ = 0; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetConsumptionNominalMaxRequest::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetConsumptionNominalMaxRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetConsumptionNominalMaxRequest::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetConsumptionNominalMaxRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:cs_lpc.SetConsumptionNominalMaxRequest) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double value = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this_._internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:cs_lpc.SetConsumptionNominalMaxRequest) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetConsumptionNominalMaxRequest::ByteSizeLong(const MessageLite& base) { + const SetConsumptionNominalMaxRequest& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetConsumptionNominalMaxRequest::ByteSizeLong() const { + const SetConsumptionNominalMaxRequest& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:cs_lpc.SetConsumptionNominalMaxRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // double value = 1; + if (::absl::bit_cast<::uint64_t>(this_._internal_value()) != 0) { + total_size += 9; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); + } + +void SetConsumptionNominalMaxRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:cs_lpc.SetConsumptionNominalMaxRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (::absl::bit_cast<::uint64_t>(from._internal_value()) != 0) { + _this->_impl_.value_ = from._impl_.value_; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SetConsumptionNominalMaxRequest::CopyFrom(const SetConsumptionNominalMaxRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cs_lpc.SetConsumptionNominalMaxRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetConsumptionNominalMaxRequest::InternalSwap(SetConsumptionNominalMaxRequest* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.value_, other->_impl_.value_); +} + +::google::protobuf::Metadata SetConsumptionNominalMaxRequest::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetConsumptionNominalMaxResponse::_Internal { + public: +}; + +SetConsumptionNominalMaxResponse::SetConsumptionNominalMaxResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(arena_constructor:cs_lpc.SetConsumptionNominalMaxResponse) +} +SetConsumptionNominalMaxResponse::SetConsumptionNominalMaxResponse( + ::google::protobuf::Arena* arena, + const SetConsumptionNominalMaxResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::internal::ZeroFieldsBase(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::internal::ZeroFieldsBase(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetConsumptionNominalMaxResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + + // @@protoc_insertion_point(copy_constructor:cs_lpc.SetConsumptionNominalMaxResponse) +} + +inline void* SetConsumptionNominalMaxResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetConsumptionNominalMaxResponse(arena); +} +constexpr auto SetConsumptionNominalMaxResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetConsumptionNominalMaxResponse), + alignof(SetConsumptionNominalMaxResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataFull SetConsumptionNominalMaxResponse::_class_data_ = { + ::google::protobuf::internal::ClassData{ + &_SetConsumptionNominalMaxResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetConsumptionNominalMaxResponse::MergeImpl, + ::google::protobuf::internal::ZeroFieldsBase::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetConsumptionNominalMaxResponse::SharedDtor, + ::google::protobuf::internal::ZeroFieldsBase::GetClearImpl(), &SetConsumptionNominalMaxResponse::ByteSizeLong, + &SetConsumptionNominalMaxResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetConsumptionNominalMaxResponse, _impl_._cached_size_), + false, + }, + &SetConsumptionNominalMaxResponse::kDescriptorMethods, + &descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, + nullptr, // tracker +}; +const ::google::protobuf::internal::ClassData* SetConsumptionNominalMaxResponse::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table); + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SetConsumptionNominalMaxResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::cs_lpc::SetConsumptionNominalMaxResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + + + + + + + + +::google::protobuf::Metadata SetConsumptionNominalMaxResponse::GetMetadata() const { + return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); +} +ConsumptionLimitRequest CreateConsumptionLimitRequest() { + ConsumptionLimitRequest res; + return res; +} + +ConsumptionLimitResponse CreateConsumptionLimitResponse( + common_types::LoadLimit* load_limit) { + ConsumptionLimitResponse res; + res.set_allocated_load_limit(load_limit); + return res; +} + +SetConsumptionLimitRequest CreateSetConsumptionLimitRequest( + common_types::LoadLimit* load_limit) { + SetConsumptionLimitRequest res; + res.set_allocated_load_limit(load_limit); + return res; +} + +SetConsumptionLimitResponse CreateSetConsumptionLimitResponse() { + SetConsumptionLimitResponse res; + return res; +} + +PendingConsumptionLimitRequest CreatePendingConsumptionLimitRequest() { + PendingConsumptionLimitRequest res; + return res; +} + +PendingConsumptionLimitResponse CreatePendingConsumptionLimitResponse( + std::map load_limits) { + PendingConsumptionLimitResponse res; + res.mutable_load_limits()->insert(load_limits.begin(), load_limits.end()); + return res; +} + +ApproveOrDenyConsumptionLimitRequest CreateApproveOrDenyConsumptionLimitRequest( + uint64_t msg_counter, + bool approve, + std::string reason) { + ApproveOrDenyConsumptionLimitRequest res; + res.set_msg_counter(msg_counter); + res.set_approve(approve); + res.set_reason(reason); + return res; +} + +ApproveOrDenyConsumptionLimitResponse CreateApproveOrDenyConsumptionLimitResponse() { + ApproveOrDenyConsumptionLimitResponse res; + return res; +} + +FailsafeConsumptionActivePowerLimitRequest CreateFailsafeConsumptionActivePowerLimitRequest() { + FailsafeConsumptionActivePowerLimitRequest res; + return res; +} + +FailsafeConsumptionActivePowerLimitResponse CreateFailsafeConsumptionActivePowerLimitResponse( + double limit, + bool is_changeable) { + FailsafeConsumptionActivePowerLimitResponse res; + res.set_limit(limit); + res.set_is_changeable(is_changeable); + return res; +} + +SetFailsafeConsumptionActivePowerLimitRequest CreateSetFailsafeConsumptionActivePowerLimitRequest( + double value, + bool is_changeable) { + SetFailsafeConsumptionActivePowerLimitRequest res; + res.set_value(value); + res.set_is_changeable(is_changeable); + return res; +} + +SetFailsafeConsumptionActivePowerLimitResponse CreateSetFailsafeConsumptionActivePowerLimitResponse() { + SetFailsafeConsumptionActivePowerLimitResponse res; + return res; +} + +FailsafeDurationMinimumRequest CreateFailsafeDurationMinimumRequest() { + FailsafeDurationMinimumRequest res; + return res; +} + +FailsafeDurationMinimumResponse CreateFailsafeDurationMinimumResponse( + int64_t duration_nanoseconds, + bool is_changeable) { + FailsafeDurationMinimumResponse res; + res.set_duration_nanoseconds(duration_nanoseconds); + res.set_is_changeable(is_changeable); + return res; +} + +SetFailsafeDurationMinimumRequest CreateSetFailsafeDurationMinimumRequest( + int64_t duration_nanoseconds, + bool is_changeable) { + SetFailsafeDurationMinimumRequest res; + res.set_duration_nanoseconds(duration_nanoseconds); + res.set_is_changeable(is_changeable); + return res; +} + +SetFailsafeDurationMinimumResponse CreateSetFailsafeDurationMinimumResponse() { + SetFailsafeDurationMinimumResponse res; + return res; +} + +StartHeartbeatRequest CreateStartHeartbeatRequest() { + StartHeartbeatRequest res; + return res; +} + +StartHeartbeatResponse CreateStartHeartbeatResponse() { + StartHeartbeatResponse res; + return res; +} + +StopHeartbeatRequest CreateStopHeartbeatRequest() { + StopHeartbeatRequest res; + return res; +} + +StopHeartbeatResponse CreateStopHeartbeatResponse() { + StopHeartbeatResponse res; + return res; +} + +IsHeartbeatWithinDurationRequest CreateIsHeartbeatWithinDurationRequest() { + IsHeartbeatWithinDurationRequest res; + return res; +} + +IsHeartbeatWithinDurationResponse CreateIsHeartbeatWithinDurationResponse( + bool is_within_duration) { + IsHeartbeatWithinDurationResponse res; + res.set_is_within_duration(is_within_duration); + return res; +} + +ConsumptionNominalMaxRequest CreateConsumptionNominalMaxRequest() { + ConsumptionNominalMaxRequest res; + return res; +} + +ConsumptionNominalMaxResponse CreateConsumptionNominalMaxResponse( + double value) { + ConsumptionNominalMaxResponse res; + res.set_value(value); + return res; +} + +SetConsumptionNominalMaxRequest CreateSetConsumptionNominalMaxRequest( + double value) { + SetConsumptionNominalMaxRequest res; + res.set_value(value); + return res; +} + +SetConsumptionNominalMaxResponse CreateSetConsumptionNominalMaxResponse() { + SetConsumptionNominalMaxResponse res; + return res; +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace cs_lpc +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.h new file mode 100644 index 0000000000..d47670ed49 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.h @@ -0,0 +1,5320 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: usecases/cs/lpc/messages.proto +// Protobuf C++ Version: 5.29.0 + +#ifndef usecases_2fcs_2flpc_2fmessages_2eproto_2epb_2eh +#define usecases_2fcs_2flpc_2fmessages_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029000 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_bases.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/map.h" // IWYU pragma: export +#include "google/protobuf/map_entry.h" +#include "google/protobuf/map_field_inl.h" +#include "google/protobuf/unknown_field_set.h" +#include "common_types/types.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_usecases_2fcs_2flpc_2fmessages_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto; +namespace cs_lpc { +class ApproveOrDenyConsumptionLimitRequest; +struct ApproveOrDenyConsumptionLimitRequestDefaultTypeInternal; +extern ApproveOrDenyConsumptionLimitRequestDefaultTypeInternal _ApproveOrDenyConsumptionLimitRequest_default_instance_; +class ApproveOrDenyConsumptionLimitResponse; +struct ApproveOrDenyConsumptionLimitResponseDefaultTypeInternal; +extern ApproveOrDenyConsumptionLimitResponseDefaultTypeInternal _ApproveOrDenyConsumptionLimitResponse_default_instance_; +class ConsumptionLimitRequest; +struct ConsumptionLimitRequestDefaultTypeInternal; +extern ConsumptionLimitRequestDefaultTypeInternal _ConsumptionLimitRequest_default_instance_; +class ConsumptionLimitResponse; +struct ConsumptionLimitResponseDefaultTypeInternal; +extern ConsumptionLimitResponseDefaultTypeInternal _ConsumptionLimitResponse_default_instance_; +class ConsumptionNominalMaxRequest; +struct ConsumptionNominalMaxRequestDefaultTypeInternal; +extern ConsumptionNominalMaxRequestDefaultTypeInternal _ConsumptionNominalMaxRequest_default_instance_; +class ConsumptionNominalMaxResponse; +struct ConsumptionNominalMaxResponseDefaultTypeInternal; +extern ConsumptionNominalMaxResponseDefaultTypeInternal _ConsumptionNominalMaxResponse_default_instance_; +class FailsafeConsumptionActivePowerLimitRequest; +struct FailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal; +extern FailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal _FailsafeConsumptionActivePowerLimitRequest_default_instance_; +class FailsafeConsumptionActivePowerLimitResponse; +struct FailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal; +extern FailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal _FailsafeConsumptionActivePowerLimitResponse_default_instance_; +class FailsafeDurationMinimumRequest; +struct FailsafeDurationMinimumRequestDefaultTypeInternal; +extern FailsafeDurationMinimumRequestDefaultTypeInternal _FailsafeDurationMinimumRequest_default_instance_; +class FailsafeDurationMinimumResponse; +struct FailsafeDurationMinimumResponseDefaultTypeInternal; +extern FailsafeDurationMinimumResponseDefaultTypeInternal _FailsafeDurationMinimumResponse_default_instance_; +class IsHeartbeatWithinDurationRequest; +struct IsHeartbeatWithinDurationRequestDefaultTypeInternal; +extern IsHeartbeatWithinDurationRequestDefaultTypeInternal _IsHeartbeatWithinDurationRequest_default_instance_; +class IsHeartbeatWithinDurationResponse; +struct IsHeartbeatWithinDurationResponseDefaultTypeInternal; +extern IsHeartbeatWithinDurationResponseDefaultTypeInternal _IsHeartbeatWithinDurationResponse_default_instance_; +class PendingConsumptionLimitRequest; +struct PendingConsumptionLimitRequestDefaultTypeInternal; +extern PendingConsumptionLimitRequestDefaultTypeInternal _PendingConsumptionLimitRequest_default_instance_; +class PendingConsumptionLimitResponse; +struct PendingConsumptionLimitResponseDefaultTypeInternal; +extern PendingConsumptionLimitResponseDefaultTypeInternal _PendingConsumptionLimitResponse_default_instance_; +class PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse; +struct PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUseDefaultTypeInternal; +extern PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUseDefaultTypeInternal _PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse_default_instance_; +class SetConsumptionLimitRequest; +struct SetConsumptionLimitRequestDefaultTypeInternal; +extern SetConsumptionLimitRequestDefaultTypeInternal _SetConsumptionLimitRequest_default_instance_; +class SetConsumptionLimitResponse; +struct SetConsumptionLimitResponseDefaultTypeInternal; +extern SetConsumptionLimitResponseDefaultTypeInternal _SetConsumptionLimitResponse_default_instance_; +class SetConsumptionNominalMaxRequest; +struct SetConsumptionNominalMaxRequestDefaultTypeInternal; +extern SetConsumptionNominalMaxRequestDefaultTypeInternal _SetConsumptionNominalMaxRequest_default_instance_; +class SetConsumptionNominalMaxResponse; +struct SetConsumptionNominalMaxResponseDefaultTypeInternal; +extern SetConsumptionNominalMaxResponseDefaultTypeInternal _SetConsumptionNominalMaxResponse_default_instance_; +class SetFailsafeConsumptionActivePowerLimitRequest; +struct SetFailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal; +extern SetFailsafeConsumptionActivePowerLimitRequestDefaultTypeInternal _SetFailsafeConsumptionActivePowerLimitRequest_default_instance_; +class SetFailsafeConsumptionActivePowerLimitResponse; +struct SetFailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal; +extern SetFailsafeConsumptionActivePowerLimitResponseDefaultTypeInternal _SetFailsafeConsumptionActivePowerLimitResponse_default_instance_; +class SetFailsafeDurationMinimumRequest; +struct SetFailsafeDurationMinimumRequestDefaultTypeInternal; +extern SetFailsafeDurationMinimumRequestDefaultTypeInternal _SetFailsafeDurationMinimumRequest_default_instance_; +class SetFailsafeDurationMinimumResponse; +struct SetFailsafeDurationMinimumResponseDefaultTypeInternal; +extern SetFailsafeDurationMinimumResponseDefaultTypeInternal _SetFailsafeDurationMinimumResponse_default_instance_; +class StartHeartbeatRequest; +struct StartHeartbeatRequestDefaultTypeInternal; +extern StartHeartbeatRequestDefaultTypeInternal _StartHeartbeatRequest_default_instance_; +class StartHeartbeatResponse; +struct StartHeartbeatResponseDefaultTypeInternal; +extern StartHeartbeatResponseDefaultTypeInternal _StartHeartbeatResponse_default_instance_; +class StopHeartbeatRequest; +struct StopHeartbeatRequestDefaultTypeInternal; +extern StopHeartbeatRequestDefaultTypeInternal _StopHeartbeatRequest_default_instance_; +class StopHeartbeatResponse; +struct StopHeartbeatResponseDefaultTypeInternal; +extern StopHeartbeatResponseDefaultTypeInternal _StopHeartbeatResponse_default_instance_; +} // namespace cs_lpc +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace cs_lpc { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class StopHeartbeatResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.StopHeartbeatResponse) */ { + public: + inline StopHeartbeatResponse() : StopHeartbeatResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StopHeartbeatResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StopHeartbeatResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR StopHeartbeatResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline StopHeartbeatResponse(const StopHeartbeatResponse& from) : StopHeartbeatResponse(nullptr, from) {} + inline StopHeartbeatResponse(StopHeartbeatResponse&& from) noexcept + : StopHeartbeatResponse(nullptr, std::move(from)) {} + inline StopHeartbeatResponse& operator=(const StopHeartbeatResponse& from) { + CopyFrom(from); + return *this; + } + inline StopHeartbeatResponse& operator=(StopHeartbeatResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StopHeartbeatResponse& default_instance() { + return *internal_default_instance(); + } + static inline const StopHeartbeatResponse* internal_default_instance() { + return reinterpret_cast( + &_StopHeartbeatResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 20; + friend void swap(StopHeartbeatResponse& a, StopHeartbeatResponse& b) { a.Swap(&b); } + inline void Swap(StopHeartbeatResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StopHeartbeatResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StopHeartbeatResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const StopHeartbeatResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const StopHeartbeatResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.StopHeartbeatResponse"; } + + protected: + explicit StopHeartbeatResponse(::google::protobuf::Arena* arena); + StopHeartbeatResponse(::google::protobuf::Arena* arena, const StopHeartbeatResponse& from); + StopHeartbeatResponse(::google::protobuf::Arena* arena, StopHeartbeatResponse&& from) noexcept + : StopHeartbeatResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.StopHeartbeatResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const StopHeartbeatResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class StopHeartbeatRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.StopHeartbeatRequest) */ { + public: + inline StopHeartbeatRequest() : StopHeartbeatRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StopHeartbeatRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StopHeartbeatRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR StopHeartbeatRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline StopHeartbeatRequest(const StopHeartbeatRequest& from) : StopHeartbeatRequest(nullptr, from) {} + inline StopHeartbeatRequest(StopHeartbeatRequest&& from) noexcept + : StopHeartbeatRequest(nullptr, std::move(from)) {} + inline StopHeartbeatRequest& operator=(const StopHeartbeatRequest& from) { + CopyFrom(from); + return *this; + } + inline StopHeartbeatRequest& operator=(StopHeartbeatRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StopHeartbeatRequest& default_instance() { + return *internal_default_instance(); + } + static inline const StopHeartbeatRequest* internal_default_instance() { + return reinterpret_cast( + &_StopHeartbeatRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 19; + friend void swap(StopHeartbeatRequest& a, StopHeartbeatRequest& b) { a.Swap(&b); } + inline void Swap(StopHeartbeatRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StopHeartbeatRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StopHeartbeatRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const StopHeartbeatRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const StopHeartbeatRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.StopHeartbeatRequest"; } + + protected: + explicit StopHeartbeatRequest(::google::protobuf::Arena* arena); + StopHeartbeatRequest(::google::protobuf::Arena* arena, const StopHeartbeatRequest& from); + StopHeartbeatRequest(::google::protobuf::Arena* arena, StopHeartbeatRequest&& from) noexcept + : StopHeartbeatRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.StopHeartbeatRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const StopHeartbeatRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class StartHeartbeatResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.StartHeartbeatResponse) */ { + public: + inline StartHeartbeatResponse() : StartHeartbeatResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StartHeartbeatResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StartHeartbeatResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR StartHeartbeatResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline StartHeartbeatResponse(const StartHeartbeatResponse& from) : StartHeartbeatResponse(nullptr, from) {} + inline StartHeartbeatResponse(StartHeartbeatResponse&& from) noexcept + : StartHeartbeatResponse(nullptr, std::move(from)) {} + inline StartHeartbeatResponse& operator=(const StartHeartbeatResponse& from) { + CopyFrom(from); + return *this; + } + inline StartHeartbeatResponse& operator=(StartHeartbeatResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StartHeartbeatResponse& default_instance() { + return *internal_default_instance(); + } + static inline const StartHeartbeatResponse* internal_default_instance() { + return reinterpret_cast( + &_StartHeartbeatResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 18; + friend void swap(StartHeartbeatResponse& a, StartHeartbeatResponse& b) { a.Swap(&b); } + inline void Swap(StartHeartbeatResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StartHeartbeatResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StartHeartbeatResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const StartHeartbeatResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const StartHeartbeatResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.StartHeartbeatResponse"; } + + protected: + explicit StartHeartbeatResponse(::google::protobuf::Arena* arena); + StartHeartbeatResponse(::google::protobuf::Arena* arena, const StartHeartbeatResponse& from); + StartHeartbeatResponse(::google::protobuf::Arena* arena, StartHeartbeatResponse&& from) noexcept + : StartHeartbeatResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.StartHeartbeatResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const StartHeartbeatResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class StartHeartbeatRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.StartHeartbeatRequest) */ { + public: + inline StartHeartbeatRequest() : StartHeartbeatRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(StartHeartbeatRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(StartHeartbeatRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR StartHeartbeatRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline StartHeartbeatRequest(const StartHeartbeatRequest& from) : StartHeartbeatRequest(nullptr, from) {} + inline StartHeartbeatRequest(StartHeartbeatRequest&& from) noexcept + : StartHeartbeatRequest(nullptr, std::move(from)) {} + inline StartHeartbeatRequest& operator=(const StartHeartbeatRequest& from) { + CopyFrom(from); + return *this; + } + inline StartHeartbeatRequest& operator=(StartHeartbeatRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StartHeartbeatRequest& default_instance() { + return *internal_default_instance(); + } + static inline const StartHeartbeatRequest* internal_default_instance() { + return reinterpret_cast( + &_StartHeartbeatRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 17; + friend void swap(StartHeartbeatRequest& a, StartHeartbeatRequest& b) { a.Swap(&b); } + inline void Swap(StartHeartbeatRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StartHeartbeatRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StartHeartbeatRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const StartHeartbeatRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const StartHeartbeatRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.StartHeartbeatRequest"; } + + protected: + explicit StartHeartbeatRequest(::google::protobuf::Arena* arena); + StartHeartbeatRequest(::google::protobuf::Arena* arena, const StartHeartbeatRequest& from); + StartHeartbeatRequest(::google::protobuf::Arena* arena, StartHeartbeatRequest&& from) noexcept + : StartHeartbeatRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.StartHeartbeatRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const StartHeartbeatRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetFailsafeDurationMinimumResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.SetFailsafeDurationMinimumResponse) */ { + public: + inline SetFailsafeDurationMinimumResponse() : SetFailsafeDurationMinimumResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetFailsafeDurationMinimumResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetFailsafeDurationMinimumResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetFailsafeDurationMinimumResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline SetFailsafeDurationMinimumResponse(const SetFailsafeDurationMinimumResponse& from) : SetFailsafeDurationMinimumResponse(nullptr, from) {} + inline SetFailsafeDurationMinimumResponse(SetFailsafeDurationMinimumResponse&& from) noexcept + : SetFailsafeDurationMinimumResponse(nullptr, std::move(from)) {} + inline SetFailsafeDurationMinimumResponse& operator=(const SetFailsafeDurationMinimumResponse& from) { + CopyFrom(from); + return *this; + } + inline SetFailsafeDurationMinimumResponse& operator=(SetFailsafeDurationMinimumResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetFailsafeDurationMinimumResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SetFailsafeDurationMinimumResponse* internal_default_instance() { + return reinterpret_cast( + &_SetFailsafeDurationMinimumResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 16; + friend void swap(SetFailsafeDurationMinimumResponse& a, SetFailsafeDurationMinimumResponse& b) { a.Swap(&b); } + inline void Swap(SetFailsafeDurationMinimumResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetFailsafeDurationMinimumResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetFailsafeDurationMinimumResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const SetFailsafeDurationMinimumResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const SetFailsafeDurationMinimumResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetFailsafeDurationMinimumResponse"; } + + protected: + explicit SetFailsafeDurationMinimumResponse(::google::protobuf::Arena* arena); + SetFailsafeDurationMinimumResponse(::google::protobuf::Arena* arena, const SetFailsafeDurationMinimumResponse& from); + SetFailsafeDurationMinimumResponse(::google::protobuf::Arena* arena, SetFailsafeDurationMinimumResponse&& from) noexcept + : SetFailsafeDurationMinimumResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.SetFailsafeDurationMinimumResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetFailsafeDurationMinimumResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetFailsafeDurationMinimumRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.SetFailsafeDurationMinimumRequest) */ { + public: + inline SetFailsafeDurationMinimumRequest() : SetFailsafeDurationMinimumRequest(nullptr) {} + ~SetFailsafeDurationMinimumRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetFailsafeDurationMinimumRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetFailsafeDurationMinimumRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetFailsafeDurationMinimumRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline SetFailsafeDurationMinimumRequest(const SetFailsafeDurationMinimumRequest& from) : SetFailsafeDurationMinimumRequest(nullptr, from) {} + inline SetFailsafeDurationMinimumRequest(SetFailsafeDurationMinimumRequest&& from) noexcept + : SetFailsafeDurationMinimumRequest(nullptr, std::move(from)) {} + inline SetFailsafeDurationMinimumRequest& operator=(const SetFailsafeDurationMinimumRequest& from) { + CopyFrom(from); + return *this; + } + inline SetFailsafeDurationMinimumRequest& operator=(SetFailsafeDurationMinimumRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetFailsafeDurationMinimumRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetFailsafeDurationMinimumRequest* internal_default_instance() { + return reinterpret_cast( + &_SetFailsafeDurationMinimumRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 15; + friend void swap(SetFailsafeDurationMinimumRequest& a, SetFailsafeDurationMinimumRequest& b) { a.Swap(&b); } + inline void Swap(SetFailsafeDurationMinimumRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetFailsafeDurationMinimumRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetFailsafeDurationMinimumRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetFailsafeDurationMinimumRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetFailsafeDurationMinimumRequest& from) { SetFailsafeDurationMinimumRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetFailsafeDurationMinimumRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetFailsafeDurationMinimumRequest"; } + + protected: + explicit SetFailsafeDurationMinimumRequest(::google::protobuf::Arena* arena); + SetFailsafeDurationMinimumRequest(::google::protobuf::Arena* arena, const SetFailsafeDurationMinimumRequest& from); + SetFailsafeDurationMinimumRequest(::google::protobuf::Arena* arena, SetFailsafeDurationMinimumRequest&& from) noexcept + : SetFailsafeDurationMinimumRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kDurationNanosecondsFieldNumber = 1, + kIsChangeableFieldNumber = 2, + }; + // int64 duration_nanoseconds = 1; + void clear_duration_nanoseconds() ; + ::int64_t duration_nanoseconds() const; + void set_duration_nanoseconds(::int64_t value); + + private: + ::int64_t _internal_duration_nanoseconds() const; + void _internal_set_duration_nanoseconds(::int64_t value); + + public: + // bool is_changeable = 2; + void clear_is_changeable() ; + bool is_changeable() const; + void set_is_changeable(bool value); + + private: + bool _internal_is_changeable() const; + void _internal_set_is_changeable(bool value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.SetFailsafeDurationMinimumRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetFailsafeDurationMinimumRequest& from_msg); + ::int64_t duration_nanoseconds_; + bool is_changeable_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetFailsafeConsumptionActivePowerLimitResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.SetFailsafeConsumptionActivePowerLimitResponse) */ { + public: + inline SetFailsafeConsumptionActivePowerLimitResponse() : SetFailsafeConsumptionActivePowerLimitResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetFailsafeConsumptionActivePowerLimitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetFailsafeConsumptionActivePowerLimitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetFailsafeConsumptionActivePowerLimitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline SetFailsafeConsumptionActivePowerLimitResponse(const SetFailsafeConsumptionActivePowerLimitResponse& from) : SetFailsafeConsumptionActivePowerLimitResponse(nullptr, from) {} + inline SetFailsafeConsumptionActivePowerLimitResponse(SetFailsafeConsumptionActivePowerLimitResponse&& from) noexcept + : SetFailsafeConsumptionActivePowerLimitResponse(nullptr, std::move(from)) {} + inline SetFailsafeConsumptionActivePowerLimitResponse& operator=(const SetFailsafeConsumptionActivePowerLimitResponse& from) { + CopyFrom(from); + return *this; + } + inline SetFailsafeConsumptionActivePowerLimitResponse& operator=(SetFailsafeConsumptionActivePowerLimitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetFailsafeConsumptionActivePowerLimitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SetFailsafeConsumptionActivePowerLimitResponse* internal_default_instance() { + return reinterpret_cast( + &_SetFailsafeConsumptionActivePowerLimitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 12; + friend void swap(SetFailsafeConsumptionActivePowerLimitResponse& a, SetFailsafeConsumptionActivePowerLimitResponse& b) { a.Swap(&b); } + inline void Swap(SetFailsafeConsumptionActivePowerLimitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetFailsafeConsumptionActivePowerLimitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetFailsafeConsumptionActivePowerLimitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const SetFailsafeConsumptionActivePowerLimitResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const SetFailsafeConsumptionActivePowerLimitResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetFailsafeConsumptionActivePowerLimitResponse"; } + + protected: + explicit SetFailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena); + SetFailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena, const SetFailsafeConsumptionActivePowerLimitResponse& from); + SetFailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena, SetFailsafeConsumptionActivePowerLimitResponse&& from) noexcept + : SetFailsafeConsumptionActivePowerLimitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.SetFailsafeConsumptionActivePowerLimitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetFailsafeConsumptionActivePowerLimitResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetFailsafeConsumptionActivePowerLimitRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) */ { + public: + inline SetFailsafeConsumptionActivePowerLimitRequest() : SetFailsafeConsumptionActivePowerLimitRequest(nullptr) {} + ~SetFailsafeConsumptionActivePowerLimitRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetFailsafeConsumptionActivePowerLimitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetFailsafeConsumptionActivePowerLimitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetFailsafeConsumptionActivePowerLimitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline SetFailsafeConsumptionActivePowerLimitRequest(const SetFailsafeConsumptionActivePowerLimitRequest& from) : SetFailsafeConsumptionActivePowerLimitRequest(nullptr, from) {} + inline SetFailsafeConsumptionActivePowerLimitRequest(SetFailsafeConsumptionActivePowerLimitRequest&& from) noexcept + : SetFailsafeConsumptionActivePowerLimitRequest(nullptr, std::move(from)) {} + inline SetFailsafeConsumptionActivePowerLimitRequest& operator=(const SetFailsafeConsumptionActivePowerLimitRequest& from) { + CopyFrom(from); + return *this; + } + inline SetFailsafeConsumptionActivePowerLimitRequest& operator=(SetFailsafeConsumptionActivePowerLimitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetFailsafeConsumptionActivePowerLimitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetFailsafeConsumptionActivePowerLimitRequest* internal_default_instance() { + return reinterpret_cast( + &_SetFailsafeConsumptionActivePowerLimitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 11; + friend void swap(SetFailsafeConsumptionActivePowerLimitRequest& a, SetFailsafeConsumptionActivePowerLimitRequest& b) { a.Swap(&b); } + inline void Swap(SetFailsafeConsumptionActivePowerLimitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetFailsafeConsumptionActivePowerLimitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetFailsafeConsumptionActivePowerLimitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetFailsafeConsumptionActivePowerLimitRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetFailsafeConsumptionActivePowerLimitRequest& from) { SetFailsafeConsumptionActivePowerLimitRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetFailsafeConsumptionActivePowerLimitRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest"; } + + protected: + explicit SetFailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena); + SetFailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena, const SetFailsafeConsumptionActivePowerLimitRequest& from); + SetFailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena, SetFailsafeConsumptionActivePowerLimitRequest&& from) noexcept + : SetFailsafeConsumptionActivePowerLimitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kValueFieldNumber = 1, + kIsChangeableFieldNumber = 2, + }; + // double value = 1; + void clear_value() ; + double value() const; + void set_value(double value); + + private: + double _internal_value() const; + void _internal_set_value(double value); + + public: + // bool is_changeable = 2; + void clear_is_changeable() ; + bool is_changeable() const; + void set_is_changeable(bool value); + + private: + bool _internal_is_changeable() const; + void _internal_set_is_changeable(bool value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetFailsafeConsumptionActivePowerLimitRequest& from_msg); + double value_; + bool is_changeable_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetConsumptionNominalMaxResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.SetConsumptionNominalMaxResponse) */ { + public: + inline SetConsumptionNominalMaxResponse() : SetConsumptionNominalMaxResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetConsumptionNominalMaxResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetConsumptionNominalMaxResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetConsumptionNominalMaxResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline SetConsumptionNominalMaxResponse(const SetConsumptionNominalMaxResponse& from) : SetConsumptionNominalMaxResponse(nullptr, from) {} + inline SetConsumptionNominalMaxResponse(SetConsumptionNominalMaxResponse&& from) noexcept + : SetConsumptionNominalMaxResponse(nullptr, std::move(from)) {} + inline SetConsumptionNominalMaxResponse& operator=(const SetConsumptionNominalMaxResponse& from) { + CopyFrom(from); + return *this; + } + inline SetConsumptionNominalMaxResponse& operator=(SetConsumptionNominalMaxResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetConsumptionNominalMaxResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SetConsumptionNominalMaxResponse* internal_default_instance() { + return reinterpret_cast( + &_SetConsumptionNominalMaxResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 26; + friend void swap(SetConsumptionNominalMaxResponse& a, SetConsumptionNominalMaxResponse& b) { a.Swap(&b); } + inline void Swap(SetConsumptionNominalMaxResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetConsumptionNominalMaxResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetConsumptionNominalMaxResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const SetConsumptionNominalMaxResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const SetConsumptionNominalMaxResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetConsumptionNominalMaxResponse"; } + + protected: + explicit SetConsumptionNominalMaxResponse(::google::protobuf::Arena* arena); + SetConsumptionNominalMaxResponse(::google::protobuf::Arena* arena, const SetConsumptionNominalMaxResponse& from); + SetConsumptionNominalMaxResponse(::google::protobuf::Arena* arena, SetConsumptionNominalMaxResponse&& from) noexcept + : SetConsumptionNominalMaxResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.SetConsumptionNominalMaxResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetConsumptionNominalMaxResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetConsumptionNominalMaxRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.SetConsumptionNominalMaxRequest) */ { + public: + inline SetConsumptionNominalMaxRequest() : SetConsumptionNominalMaxRequest(nullptr) {} + ~SetConsumptionNominalMaxRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetConsumptionNominalMaxRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetConsumptionNominalMaxRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetConsumptionNominalMaxRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline SetConsumptionNominalMaxRequest(const SetConsumptionNominalMaxRequest& from) : SetConsumptionNominalMaxRequest(nullptr, from) {} + inline SetConsumptionNominalMaxRequest(SetConsumptionNominalMaxRequest&& from) noexcept + : SetConsumptionNominalMaxRequest(nullptr, std::move(from)) {} + inline SetConsumptionNominalMaxRequest& operator=(const SetConsumptionNominalMaxRequest& from) { + CopyFrom(from); + return *this; + } + inline SetConsumptionNominalMaxRequest& operator=(SetConsumptionNominalMaxRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetConsumptionNominalMaxRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetConsumptionNominalMaxRequest* internal_default_instance() { + return reinterpret_cast( + &_SetConsumptionNominalMaxRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 25; + friend void swap(SetConsumptionNominalMaxRequest& a, SetConsumptionNominalMaxRequest& b) { a.Swap(&b); } + inline void Swap(SetConsumptionNominalMaxRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetConsumptionNominalMaxRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetConsumptionNominalMaxRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetConsumptionNominalMaxRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetConsumptionNominalMaxRequest& from) { SetConsumptionNominalMaxRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetConsumptionNominalMaxRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetConsumptionNominalMaxRequest"; } + + protected: + explicit SetConsumptionNominalMaxRequest(::google::protobuf::Arena* arena); + SetConsumptionNominalMaxRequest(::google::protobuf::Arena* arena, const SetConsumptionNominalMaxRequest& from); + SetConsumptionNominalMaxRequest(::google::protobuf::Arena* arena, SetConsumptionNominalMaxRequest&& from) noexcept + : SetConsumptionNominalMaxRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kValueFieldNumber = 1, + }; + // double value = 1; + void clear_value() ; + double value() const; + void set_value(double value); + + private: + double _internal_value() const; + void _internal_set_value(double value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.SetConsumptionNominalMaxRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetConsumptionNominalMaxRequest& from_msg); + double value_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetConsumptionLimitResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.SetConsumptionLimitResponse) */ { + public: + inline SetConsumptionLimitResponse() : SetConsumptionLimitResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetConsumptionLimitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetConsumptionLimitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetConsumptionLimitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline SetConsumptionLimitResponse(const SetConsumptionLimitResponse& from) : SetConsumptionLimitResponse(nullptr, from) {} + inline SetConsumptionLimitResponse(SetConsumptionLimitResponse&& from) noexcept + : SetConsumptionLimitResponse(nullptr, std::move(from)) {} + inline SetConsumptionLimitResponse& operator=(const SetConsumptionLimitResponse& from) { + CopyFrom(from); + return *this; + } + inline SetConsumptionLimitResponse& operator=(SetConsumptionLimitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetConsumptionLimitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SetConsumptionLimitResponse* internal_default_instance() { + return reinterpret_cast( + &_SetConsumptionLimitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(SetConsumptionLimitResponse& a, SetConsumptionLimitResponse& b) { a.Swap(&b); } + inline void Swap(SetConsumptionLimitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetConsumptionLimitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetConsumptionLimitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const SetConsumptionLimitResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const SetConsumptionLimitResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetConsumptionLimitResponse"; } + + protected: + explicit SetConsumptionLimitResponse(::google::protobuf::Arena* arena); + SetConsumptionLimitResponse(::google::protobuf::Arena* arena, const SetConsumptionLimitResponse& from); + SetConsumptionLimitResponse(::google::protobuf::Arena* arena, SetConsumptionLimitResponse&& from) noexcept + : SetConsumptionLimitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.SetConsumptionLimitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetConsumptionLimitResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class PendingConsumptionLimitRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.PendingConsumptionLimitRequest) */ { + public: + inline PendingConsumptionLimitRequest() : PendingConsumptionLimitRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PendingConsumptionLimitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PendingConsumptionLimitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PendingConsumptionLimitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline PendingConsumptionLimitRequest(const PendingConsumptionLimitRequest& from) : PendingConsumptionLimitRequest(nullptr, from) {} + inline PendingConsumptionLimitRequest(PendingConsumptionLimitRequest&& from) noexcept + : PendingConsumptionLimitRequest(nullptr, std::move(from)) {} + inline PendingConsumptionLimitRequest& operator=(const PendingConsumptionLimitRequest& from) { + CopyFrom(from); + return *this; + } + inline PendingConsumptionLimitRequest& operator=(PendingConsumptionLimitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PendingConsumptionLimitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const PendingConsumptionLimitRequest* internal_default_instance() { + return reinterpret_cast( + &_PendingConsumptionLimitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + friend void swap(PendingConsumptionLimitRequest& a, PendingConsumptionLimitRequest& b) { a.Swap(&b); } + inline void Swap(PendingConsumptionLimitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PendingConsumptionLimitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PendingConsumptionLimitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const PendingConsumptionLimitRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const PendingConsumptionLimitRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.PendingConsumptionLimitRequest"; } + + protected: + explicit PendingConsumptionLimitRequest(::google::protobuf::Arena* arena); + PendingConsumptionLimitRequest(::google::protobuf::Arena* arena, const PendingConsumptionLimitRequest& from); + PendingConsumptionLimitRequest(::google::protobuf::Arena* arena, PendingConsumptionLimitRequest&& from) noexcept + : PendingConsumptionLimitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.PendingConsumptionLimitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const PendingConsumptionLimitRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class IsHeartbeatWithinDurationResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.IsHeartbeatWithinDurationResponse) */ { + public: + inline IsHeartbeatWithinDurationResponse() : IsHeartbeatWithinDurationResponse(nullptr) {} + ~IsHeartbeatWithinDurationResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IsHeartbeatWithinDurationResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IsHeartbeatWithinDurationResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR IsHeartbeatWithinDurationResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline IsHeartbeatWithinDurationResponse(const IsHeartbeatWithinDurationResponse& from) : IsHeartbeatWithinDurationResponse(nullptr, from) {} + inline IsHeartbeatWithinDurationResponse(IsHeartbeatWithinDurationResponse&& from) noexcept + : IsHeartbeatWithinDurationResponse(nullptr, std::move(from)) {} + inline IsHeartbeatWithinDurationResponse& operator=(const IsHeartbeatWithinDurationResponse& from) { + CopyFrom(from); + return *this; + } + inline IsHeartbeatWithinDurationResponse& operator=(IsHeartbeatWithinDurationResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const IsHeartbeatWithinDurationResponse& default_instance() { + return *internal_default_instance(); + } + static inline const IsHeartbeatWithinDurationResponse* internal_default_instance() { + return reinterpret_cast( + &_IsHeartbeatWithinDurationResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 22; + friend void swap(IsHeartbeatWithinDurationResponse& a, IsHeartbeatWithinDurationResponse& b) { a.Swap(&b); } + inline void Swap(IsHeartbeatWithinDurationResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(IsHeartbeatWithinDurationResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + IsHeartbeatWithinDurationResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const IsHeartbeatWithinDurationResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const IsHeartbeatWithinDurationResponse& from) { IsHeartbeatWithinDurationResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(IsHeartbeatWithinDurationResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.IsHeartbeatWithinDurationResponse"; } + + protected: + explicit IsHeartbeatWithinDurationResponse(::google::protobuf::Arena* arena); + IsHeartbeatWithinDurationResponse(::google::protobuf::Arena* arena, const IsHeartbeatWithinDurationResponse& from); + IsHeartbeatWithinDurationResponse(::google::protobuf::Arena* arena, IsHeartbeatWithinDurationResponse&& from) noexcept + : IsHeartbeatWithinDurationResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIsWithinDurationFieldNumber = 1, + }; + // bool is_within_duration = 1; + void clear_is_within_duration() ; + bool is_within_duration() const; + void set_is_within_duration(bool value); + + private: + bool _internal_is_within_duration() const; + void _internal_set_is_within_duration(bool value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.IsHeartbeatWithinDurationResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const IsHeartbeatWithinDurationResponse& from_msg); + bool is_within_duration_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class IsHeartbeatWithinDurationRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.IsHeartbeatWithinDurationRequest) */ { + public: + inline IsHeartbeatWithinDurationRequest() : IsHeartbeatWithinDurationRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IsHeartbeatWithinDurationRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IsHeartbeatWithinDurationRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR IsHeartbeatWithinDurationRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline IsHeartbeatWithinDurationRequest(const IsHeartbeatWithinDurationRequest& from) : IsHeartbeatWithinDurationRequest(nullptr, from) {} + inline IsHeartbeatWithinDurationRequest(IsHeartbeatWithinDurationRequest&& from) noexcept + : IsHeartbeatWithinDurationRequest(nullptr, std::move(from)) {} + inline IsHeartbeatWithinDurationRequest& operator=(const IsHeartbeatWithinDurationRequest& from) { + CopyFrom(from); + return *this; + } + inline IsHeartbeatWithinDurationRequest& operator=(IsHeartbeatWithinDurationRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const IsHeartbeatWithinDurationRequest& default_instance() { + return *internal_default_instance(); + } + static inline const IsHeartbeatWithinDurationRequest* internal_default_instance() { + return reinterpret_cast( + &_IsHeartbeatWithinDurationRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 21; + friend void swap(IsHeartbeatWithinDurationRequest& a, IsHeartbeatWithinDurationRequest& b) { a.Swap(&b); } + inline void Swap(IsHeartbeatWithinDurationRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(IsHeartbeatWithinDurationRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + IsHeartbeatWithinDurationRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const IsHeartbeatWithinDurationRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const IsHeartbeatWithinDurationRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.IsHeartbeatWithinDurationRequest"; } + + protected: + explicit IsHeartbeatWithinDurationRequest(::google::protobuf::Arena* arena); + IsHeartbeatWithinDurationRequest(::google::protobuf::Arena* arena, const IsHeartbeatWithinDurationRequest& from); + IsHeartbeatWithinDurationRequest(::google::protobuf::Arena* arena, IsHeartbeatWithinDurationRequest&& from) noexcept + : IsHeartbeatWithinDurationRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.IsHeartbeatWithinDurationRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const IsHeartbeatWithinDurationRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class FailsafeDurationMinimumResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.FailsafeDurationMinimumResponse) */ { + public: + inline FailsafeDurationMinimumResponse() : FailsafeDurationMinimumResponse(nullptr) {} + ~FailsafeDurationMinimumResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(FailsafeDurationMinimumResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(FailsafeDurationMinimumResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR FailsafeDurationMinimumResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline FailsafeDurationMinimumResponse(const FailsafeDurationMinimumResponse& from) : FailsafeDurationMinimumResponse(nullptr, from) {} + inline FailsafeDurationMinimumResponse(FailsafeDurationMinimumResponse&& from) noexcept + : FailsafeDurationMinimumResponse(nullptr, std::move(from)) {} + inline FailsafeDurationMinimumResponse& operator=(const FailsafeDurationMinimumResponse& from) { + CopyFrom(from); + return *this; + } + inline FailsafeDurationMinimumResponse& operator=(FailsafeDurationMinimumResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FailsafeDurationMinimumResponse& default_instance() { + return *internal_default_instance(); + } + static inline const FailsafeDurationMinimumResponse* internal_default_instance() { + return reinterpret_cast( + &_FailsafeDurationMinimumResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 14; + friend void swap(FailsafeDurationMinimumResponse& a, FailsafeDurationMinimumResponse& b) { a.Swap(&b); } + inline void Swap(FailsafeDurationMinimumResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FailsafeDurationMinimumResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FailsafeDurationMinimumResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const FailsafeDurationMinimumResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const FailsafeDurationMinimumResponse& from) { FailsafeDurationMinimumResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(FailsafeDurationMinimumResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.FailsafeDurationMinimumResponse"; } + + protected: + explicit FailsafeDurationMinimumResponse(::google::protobuf::Arena* arena); + FailsafeDurationMinimumResponse(::google::protobuf::Arena* arena, const FailsafeDurationMinimumResponse& from); + FailsafeDurationMinimumResponse(::google::protobuf::Arena* arena, FailsafeDurationMinimumResponse&& from) noexcept + : FailsafeDurationMinimumResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kDurationNanosecondsFieldNumber = 1, + kIsChangeableFieldNumber = 2, + }; + // int64 duration_nanoseconds = 1; + void clear_duration_nanoseconds() ; + ::int64_t duration_nanoseconds() const; + void set_duration_nanoseconds(::int64_t value); + + private: + ::int64_t _internal_duration_nanoseconds() const; + void _internal_set_duration_nanoseconds(::int64_t value); + + public: + // bool is_changeable = 2; + void clear_is_changeable() ; + bool is_changeable() const; + void set_is_changeable(bool value); + + private: + bool _internal_is_changeable() const; + void _internal_set_is_changeable(bool value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.FailsafeDurationMinimumResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const FailsafeDurationMinimumResponse& from_msg); + ::int64_t duration_nanoseconds_; + bool is_changeable_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class FailsafeDurationMinimumRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.FailsafeDurationMinimumRequest) */ { + public: + inline FailsafeDurationMinimumRequest() : FailsafeDurationMinimumRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(FailsafeDurationMinimumRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(FailsafeDurationMinimumRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR FailsafeDurationMinimumRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline FailsafeDurationMinimumRequest(const FailsafeDurationMinimumRequest& from) : FailsafeDurationMinimumRequest(nullptr, from) {} + inline FailsafeDurationMinimumRequest(FailsafeDurationMinimumRequest&& from) noexcept + : FailsafeDurationMinimumRequest(nullptr, std::move(from)) {} + inline FailsafeDurationMinimumRequest& operator=(const FailsafeDurationMinimumRequest& from) { + CopyFrom(from); + return *this; + } + inline FailsafeDurationMinimumRequest& operator=(FailsafeDurationMinimumRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FailsafeDurationMinimumRequest& default_instance() { + return *internal_default_instance(); + } + static inline const FailsafeDurationMinimumRequest* internal_default_instance() { + return reinterpret_cast( + &_FailsafeDurationMinimumRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 13; + friend void swap(FailsafeDurationMinimumRequest& a, FailsafeDurationMinimumRequest& b) { a.Swap(&b); } + inline void Swap(FailsafeDurationMinimumRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FailsafeDurationMinimumRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FailsafeDurationMinimumRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const FailsafeDurationMinimumRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const FailsafeDurationMinimumRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.FailsafeDurationMinimumRequest"; } + + protected: + explicit FailsafeDurationMinimumRequest(::google::protobuf::Arena* arena); + FailsafeDurationMinimumRequest(::google::protobuf::Arena* arena, const FailsafeDurationMinimumRequest& from); + FailsafeDurationMinimumRequest(::google::protobuf::Arena* arena, FailsafeDurationMinimumRequest&& from) noexcept + : FailsafeDurationMinimumRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.FailsafeDurationMinimumRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const FailsafeDurationMinimumRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class FailsafeConsumptionActivePowerLimitResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) */ { + public: + inline FailsafeConsumptionActivePowerLimitResponse() : FailsafeConsumptionActivePowerLimitResponse(nullptr) {} + ~FailsafeConsumptionActivePowerLimitResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(FailsafeConsumptionActivePowerLimitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(FailsafeConsumptionActivePowerLimitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR FailsafeConsumptionActivePowerLimitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline FailsafeConsumptionActivePowerLimitResponse(const FailsafeConsumptionActivePowerLimitResponse& from) : FailsafeConsumptionActivePowerLimitResponse(nullptr, from) {} + inline FailsafeConsumptionActivePowerLimitResponse(FailsafeConsumptionActivePowerLimitResponse&& from) noexcept + : FailsafeConsumptionActivePowerLimitResponse(nullptr, std::move(from)) {} + inline FailsafeConsumptionActivePowerLimitResponse& operator=(const FailsafeConsumptionActivePowerLimitResponse& from) { + CopyFrom(from); + return *this; + } + inline FailsafeConsumptionActivePowerLimitResponse& operator=(FailsafeConsumptionActivePowerLimitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FailsafeConsumptionActivePowerLimitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const FailsafeConsumptionActivePowerLimitResponse* internal_default_instance() { + return reinterpret_cast( + &_FailsafeConsumptionActivePowerLimitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 10; + friend void swap(FailsafeConsumptionActivePowerLimitResponse& a, FailsafeConsumptionActivePowerLimitResponse& b) { a.Swap(&b); } + inline void Swap(FailsafeConsumptionActivePowerLimitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FailsafeConsumptionActivePowerLimitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FailsafeConsumptionActivePowerLimitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const FailsafeConsumptionActivePowerLimitResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const FailsafeConsumptionActivePowerLimitResponse& from) { FailsafeConsumptionActivePowerLimitResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(FailsafeConsumptionActivePowerLimitResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.FailsafeConsumptionActivePowerLimitResponse"; } + + protected: + explicit FailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena); + FailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena, const FailsafeConsumptionActivePowerLimitResponse& from); + FailsafeConsumptionActivePowerLimitResponse(::google::protobuf::Arena* arena, FailsafeConsumptionActivePowerLimitResponse&& from) noexcept + : FailsafeConsumptionActivePowerLimitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kLimitFieldNumber = 1, + kIsChangeableFieldNumber = 2, + }; + // double limit = 1; + void clear_limit() ; + double limit() const; + void set_limit(double value); + + private: + double _internal_limit() const; + void _internal_set_limit(double value); + + public: + // bool is_changeable = 2; + void clear_is_changeable() ; + bool is_changeable() const; + void set_is_changeable(bool value); + + private: + bool _internal_is_changeable() const; + void _internal_set_is_changeable(bool value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.FailsafeConsumptionActivePowerLimitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const FailsafeConsumptionActivePowerLimitResponse& from_msg); + double limit_; + bool is_changeable_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class FailsafeConsumptionActivePowerLimitRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.FailsafeConsumptionActivePowerLimitRequest) */ { + public: + inline FailsafeConsumptionActivePowerLimitRequest() : FailsafeConsumptionActivePowerLimitRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(FailsafeConsumptionActivePowerLimitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(FailsafeConsumptionActivePowerLimitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR FailsafeConsumptionActivePowerLimitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline FailsafeConsumptionActivePowerLimitRequest(const FailsafeConsumptionActivePowerLimitRequest& from) : FailsafeConsumptionActivePowerLimitRequest(nullptr, from) {} + inline FailsafeConsumptionActivePowerLimitRequest(FailsafeConsumptionActivePowerLimitRequest&& from) noexcept + : FailsafeConsumptionActivePowerLimitRequest(nullptr, std::move(from)) {} + inline FailsafeConsumptionActivePowerLimitRequest& operator=(const FailsafeConsumptionActivePowerLimitRequest& from) { + CopyFrom(from); + return *this; + } + inline FailsafeConsumptionActivePowerLimitRequest& operator=(FailsafeConsumptionActivePowerLimitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FailsafeConsumptionActivePowerLimitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const FailsafeConsumptionActivePowerLimitRequest* internal_default_instance() { + return reinterpret_cast( + &_FailsafeConsumptionActivePowerLimitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 9; + friend void swap(FailsafeConsumptionActivePowerLimitRequest& a, FailsafeConsumptionActivePowerLimitRequest& b) { a.Swap(&b); } + inline void Swap(FailsafeConsumptionActivePowerLimitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FailsafeConsumptionActivePowerLimitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FailsafeConsumptionActivePowerLimitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const FailsafeConsumptionActivePowerLimitRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const FailsafeConsumptionActivePowerLimitRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.FailsafeConsumptionActivePowerLimitRequest"; } + + protected: + explicit FailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena); + FailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena, const FailsafeConsumptionActivePowerLimitRequest& from); + FailsafeConsumptionActivePowerLimitRequest(::google::protobuf::Arena* arena, FailsafeConsumptionActivePowerLimitRequest&& from) noexcept + : FailsafeConsumptionActivePowerLimitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.FailsafeConsumptionActivePowerLimitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const FailsafeConsumptionActivePowerLimitRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class ConsumptionNominalMaxResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.ConsumptionNominalMaxResponse) */ { + public: + inline ConsumptionNominalMaxResponse() : ConsumptionNominalMaxResponse(nullptr) {} + ~ConsumptionNominalMaxResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConsumptionNominalMaxResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConsumptionNominalMaxResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConsumptionNominalMaxResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline ConsumptionNominalMaxResponse(const ConsumptionNominalMaxResponse& from) : ConsumptionNominalMaxResponse(nullptr, from) {} + inline ConsumptionNominalMaxResponse(ConsumptionNominalMaxResponse&& from) noexcept + : ConsumptionNominalMaxResponse(nullptr, std::move(from)) {} + inline ConsumptionNominalMaxResponse& operator=(const ConsumptionNominalMaxResponse& from) { + CopyFrom(from); + return *this; + } + inline ConsumptionNominalMaxResponse& operator=(ConsumptionNominalMaxResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ConsumptionNominalMaxResponse& default_instance() { + return *internal_default_instance(); + } + static inline const ConsumptionNominalMaxResponse* internal_default_instance() { + return reinterpret_cast( + &_ConsumptionNominalMaxResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 24; + friend void swap(ConsumptionNominalMaxResponse& a, ConsumptionNominalMaxResponse& b) { a.Swap(&b); } + inline void Swap(ConsumptionNominalMaxResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ConsumptionNominalMaxResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConsumptionNominalMaxResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ConsumptionNominalMaxResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ConsumptionNominalMaxResponse& from) { ConsumptionNominalMaxResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConsumptionNominalMaxResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.ConsumptionNominalMaxResponse"; } + + protected: + explicit ConsumptionNominalMaxResponse(::google::protobuf::Arena* arena); + ConsumptionNominalMaxResponse(::google::protobuf::Arena* arena, const ConsumptionNominalMaxResponse& from); + ConsumptionNominalMaxResponse(::google::protobuf::Arena* arena, ConsumptionNominalMaxResponse&& from) noexcept + : ConsumptionNominalMaxResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kValueFieldNumber = 1, + }; + // double value = 1; + void clear_value() ; + double value() const; + void set_value(double value); + + private: + double _internal_value() const; + void _internal_set_value(double value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.ConsumptionNominalMaxResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ConsumptionNominalMaxResponse& from_msg); + double value_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class ConsumptionNominalMaxRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.ConsumptionNominalMaxRequest) */ { + public: + inline ConsumptionNominalMaxRequest() : ConsumptionNominalMaxRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConsumptionNominalMaxRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConsumptionNominalMaxRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConsumptionNominalMaxRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline ConsumptionNominalMaxRequest(const ConsumptionNominalMaxRequest& from) : ConsumptionNominalMaxRequest(nullptr, from) {} + inline ConsumptionNominalMaxRequest(ConsumptionNominalMaxRequest&& from) noexcept + : ConsumptionNominalMaxRequest(nullptr, std::move(from)) {} + inline ConsumptionNominalMaxRequest& operator=(const ConsumptionNominalMaxRequest& from) { + CopyFrom(from); + return *this; + } + inline ConsumptionNominalMaxRequest& operator=(ConsumptionNominalMaxRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ConsumptionNominalMaxRequest& default_instance() { + return *internal_default_instance(); + } + static inline const ConsumptionNominalMaxRequest* internal_default_instance() { + return reinterpret_cast( + &_ConsumptionNominalMaxRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 23; + friend void swap(ConsumptionNominalMaxRequest& a, ConsumptionNominalMaxRequest& b) { a.Swap(&b); } + inline void Swap(ConsumptionNominalMaxRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ConsumptionNominalMaxRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConsumptionNominalMaxRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const ConsumptionNominalMaxRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const ConsumptionNominalMaxRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.ConsumptionNominalMaxRequest"; } + + protected: + explicit ConsumptionNominalMaxRequest(::google::protobuf::Arena* arena); + ConsumptionNominalMaxRequest(::google::protobuf::Arena* arena, const ConsumptionNominalMaxRequest& from); + ConsumptionNominalMaxRequest(::google::protobuf::Arena* arena, ConsumptionNominalMaxRequest&& from) noexcept + : ConsumptionNominalMaxRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.ConsumptionNominalMaxRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ConsumptionNominalMaxRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class ConsumptionLimitRequest final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.ConsumptionLimitRequest) */ { + public: + inline ConsumptionLimitRequest() : ConsumptionLimitRequest(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConsumptionLimitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConsumptionLimitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConsumptionLimitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline ConsumptionLimitRequest(const ConsumptionLimitRequest& from) : ConsumptionLimitRequest(nullptr, from) {} + inline ConsumptionLimitRequest(ConsumptionLimitRequest&& from) noexcept + : ConsumptionLimitRequest(nullptr, std::move(from)) {} + inline ConsumptionLimitRequest& operator=(const ConsumptionLimitRequest& from) { + CopyFrom(from); + return *this; + } + inline ConsumptionLimitRequest& operator=(ConsumptionLimitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ConsumptionLimitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const ConsumptionLimitRequest* internal_default_instance() { + return reinterpret_cast( + &_ConsumptionLimitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(ConsumptionLimitRequest& a, ConsumptionLimitRequest& b) { a.Swap(&b); } + inline void Swap(ConsumptionLimitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ConsumptionLimitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConsumptionLimitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const ConsumptionLimitRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const ConsumptionLimitRequest& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.ConsumptionLimitRequest"; } + + protected: + explicit ConsumptionLimitRequest(::google::protobuf::Arena* arena); + ConsumptionLimitRequest(::google::protobuf::Arena* arena, const ConsumptionLimitRequest& from); + ConsumptionLimitRequest(::google::protobuf::Arena* arena, ConsumptionLimitRequest&& from) noexcept + : ConsumptionLimitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.ConsumptionLimitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ConsumptionLimitRequest& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class ApproveOrDenyConsumptionLimitResponse final + : public ::google::protobuf::internal::ZeroFieldsBase +/* @@protoc_insertion_point(class_definition:cs_lpc.ApproveOrDenyConsumptionLimitResponse) */ { + public: + inline ApproveOrDenyConsumptionLimitResponse() : ApproveOrDenyConsumptionLimitResponse(nullptr) {} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ApproveOrDenyConsumptionLimitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ApproveOrDenyConsumptionLimitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ApproveOrDenyConsumptionLimitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline ApproveOrDenyConsumptionLimitResponse(const ApproveOrDenyConsumptionLimitResponse& from) : ApproveOrDenyConsumptionLimitResponse(nullptr, from) {} + inline ApproveOrDenyConsumptionLimitResponse(ApproveOrDenyConsumptionLimitResponse&& from) noexcept + : ApproveOrDenyConsumptionLimitResponse(nullptr, std::move(from)) {} + inline ApproveOrDenyConsumptionLimitResponse& operator=(const ApproveOrDenyConsumptionLimitResponse& from) { + CopyFrom(from); + return *this; + } + inline ApproveOrDenyConsumptionLimitResponse& operator=(ApproveOrDenyConsumptionLimitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ApproveOrDenyConsumptionLimitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const ApproveOrDenyConsumptionLimitResponse* internal_default_instance() { + return reinterpret_cast( + &_ApproveOrDenyConsumptionLimitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + friend void swap(ApproveOrDenyConsumptionLimitResponse& a, ApproveOrDenyConsumptionLimitResponse& b) { a.Swap(&b); } + inline void Swap(ApproveOrDenyConsumptionLimitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ApproveOrDenyConsumptionLimitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ApproveOrDenyConsumptionLimitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); + } + using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const ApproveOrDenyConsumptionLimitResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const ApproveOrDenyConsumptionLimitResponse& from) { + ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + + public: + bool IsInitialized() const { + return true; + } + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.ApproveOrDenyConsumptionLimitResponse"; } + + protected: + explicit ApproveOrDenyConsumptionLimitResponse(::google::protobuf::Arena* arena); + ApproveOrDenyConsumptionLimitResponse(::google::protobuf::Arena* arena, const ApproveOrDenyConsumptionLimitResponse& from); + ApproveOrDenyConsumptionLimitResponse(::google::protobuf::Arena* arena, ApproveOrDenyConsumptionLimitResponse&& from) noexcept + : ApproveOrDenyConsumptionLimitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:cs_lpc.ApproveOrDenyConsumptionLimitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ApproveOrDenyConsumptionLimitResponse& from_msg); + PROTOBUF_TSAN_DECLARE_MEMBER + }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class ApproveOrDenyConsumptionLimitRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.ApproveOrDenyConsumptionLimitRequest) */ { + public: + inline ApproveOrDenyConsumptionLimitRequest() : ApproveOrDenyConsumptionLimitRequest(nullptr) {} + ~ApproveOrDenyConsumptionLimitRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ApproveOrDenyConsumptionLimitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ApproveOrDenyConsumptionLimitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ApproveOrDenyConsumptionLimitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline ApproveOrDenyConsumptionLimitRequest(const ApproveOrDenyConsumptionLimitRequest& from) : ApproveOrDenyConsumptionLimitRequest(nullptr, from) {} + inline ApproveOrDenyConsumptionLimitRequest(ApproveOrDenyConsumptionLimitRequest&& from) noexcept + : ApproveOrDenyConsumptionLimitRequest(nullptr, std::move(from)) {} + inline ApproveOrDenyConsumptionLimitRequest& operator=(const ApproveOrDenyConsumptionLimitRequest& from) { + CopyFrom(from); + return *this; + } + inline ApproveOrDenyConsumptionLimitRequest& operator=(ApproveOrDenyConsumptionLimitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ApproveOrDenyConsumptionLimitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const ApproveOrDenyConsumptionLimitRequest* internal_default_instance() { + return reinterpret_cast( + &_ApproveOrDenyConsumptionLimitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 7; + friend void swap(ApproveOrDenyConsumptionLimitRequest& a, ApproveOrDenyConsumptionLimitRequest& b) { a.Swap(&b); } + inline void Swap(ApproveOrDenyConsumptionLimitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ApproveOrDenyConsumptionLimitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ApproveOrDenyConsumptionLimitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ApproveOrDenyConsumptionLimitRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ApproveOrDenyConsumptionLimitRequest& from) { ApproveOrDenyConsumptionLimitRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ApproveOrDenyConsumptionLimitRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.ApproveOrDenyConsumptionLimitRequest"; } + + protected: + explicit ApproveOrDenyConsumptionLimitRequest(::google::protobuf::Arena* arena); + ApproveOrDenyConsumptionLimitRequest(::google::protobuf::Arena* arena, const ApproveOrDenyConsumptionLimitRequest& from); + ApproveOrDenyConsumptionLimitRequest(::google::protobuf::Arena* arena, ApproveOrDenyConsumptionLimitRequest&& from) noexcept + : ApproveOrDenyConsumptionLimitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kReasonFieldNumber = 3, + kMsgCounterFieldNumber = 1, + kApproveFieldNumber = 2, + }; + // string reason = 3; + void clear_reason() ; + 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); + + private: + const std::string& _internal_reason() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_reason( + const std::string& value); + std::string* _internal_mutable_reason(); + + public: + // uint64 msg_counter = 1; + void clear_msg_counter() ; + ::uint64_t msg_counter() const; + void set_msg_counter(::uint64_t value); + + private: + ::uint64_t _internal_msg_counter() const; + void _internal_set_msg_counter(::uint64_t value); + + public: + // bool approve = 2; + void clear_approve() ; + bool approve() const; + void set_approve(bool value); + + private: + bool _internal_approve() const; + void _internal_set_approve(bool value); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.ApproveOrDenyConsumptionLimitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 58, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ApproveOrDenyConsumptionLimitRequest& from_msg); + ::google::protobuf::internal::ArenaStringPtr reason_; + ::uint64_t msg_counter_; + bool approve_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class SetConsumptionLimitRequest final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.SetConsumptionLimitRequest) */ { + public: + inline SetConsumptionLimitRequest() : SetConsumptionLimitRequest(nullptr) {} + ~SetConsumptionLimitRequest() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetConsumptionLimitRequest* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetConsumptionLimitRequest)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetConsumptionLimitRequest( + ::google::protobuf::internal::ConstantInitialized); + + inline SetConsumptionLimitRequest(const SetConsumptionLimitRequest& from) : SetConsumptionLimitRequest(nullptr, from) {} + inline SetConsumptionLimitRequest(SetConsumptionLimitRequest&& from) noexcept + : SetConsumptionLimitRequest(nullptr, std::move(from)) {} + inline SetConsumptionLimitRequest& operator=(const SetConsumptionLimitRequest& from) { + CopyFrom(from); + return *this; + } + inline SetConsumptionLimitRequest& operator=(SetConsumptionLimitRequest&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetConsumptionLimitRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetConsumptionLimitRequest* internal_default_instance() { + return reinterpret_cast( + &_SetConsumptionLimitRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(SetConsumptionLimitRequest& a, SetConsumptionLimitRequest& b) { a.Swap(&b); } + inline void Swap(SetConsumptionLimitRequest* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetConsumptionLimitRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetConsumptionLimitRequest* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetConsumptionLimitRequest& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetConsumptionLimitRequest& from) { SetConsumptionLimitRequest::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetConsumptionLimitRequest* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.SetConsumptionLimitRequest"; } + + protected: + explicit SetConsumptionLimitRequest(::google::protobuf::Arena* arena); + SetConsumptionLimitRequest(::google::protobuf::Arena* arena, const SetConsumptionLimitRequest& from); + SetConsumptionLimitRequest(::google::protobuf::Arena* arena, SetConsumptionLimitRequest&& from) noexcept + : SetConsumptionLimitRequest(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kLoadLimitFieldNumber = 1, + }; + // .common_types.LoadLimit load_limit = 1; + bool has_load_limit() const; + void clear_load_limit() ; + const ::common_types::LoadLimit& load_limit() const; + PROTOBUF_NODISCARD ::common_types::LoadLimit* release_load_limit(); + ::common_types::LoadLimit* mutable_load_limit(); + void set_allocated_load_limit(::common_types::LoadLimit* value); + void unsafe_arena_set_allocated_load_limit(::common_types::LoadLimit* value); + ::common_types::LoadLimit* unsafe_arena_release_load_limit(); + + private: + const ::common_types::LoadLimit& _internal_load_limit() const; + ::common_types::LoadLimit* _internal_mutable_load_limit(); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.SetConsumptionLimitRequest) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetConsumptionLimitRequest& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::common_types::LoadLimit* load_limit_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse final + : public ::google::protobuf::internal::MapEntry< + ::uint64_t, ::google::protobuf::Message, + ::google::protobuf::internal::WireFormatLite::TYPE_UINT64, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE> { + public: + using SuperType = ::google::protobuf::internal::MapEntry< + ::uint64_t, ::google::protobuf::Message, + ::google::protobuf::internal::WireFormatLite::TYPE_UINT64, + ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>; + PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse( + ::google::protobuf::internal::ConstantInitialized); + explicit PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse(::google::protobuf::Arena* arena); + static const PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse* internal_default_instance() { + return reinterpret_cast( + &_PendingConsumptionLimitResponse_LoadLimitsEntry_DoNotUse_default_instance_); + } + + + private: + friend class ::google::protobuf::MessageLite; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 1, + 0, 2> + _table_; + + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; +}; +// ------------------------------------------------------------------- + +class ConsumptionLimitResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.ConsumptionLimitResponse) */ { + public: + inline ConsumptionLimitResponse() : ConsumptionLimitResponse(nullptr) {} + ~ConsumptionLimitResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ConsumptionLimitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ConsumptionLimitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ConsumptionLimitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline ConsumptionLimitResponse(const ConsumptionLimitResponse& from) : ConsumptionLimitResponse(nullptr, from) {} + inline ConsumptionLimitResponse(ConsumptionLimitResponse&& from) noexcept + : ConsumptionLimitResponse(nullptr, std::move(from)) {} + inline ConsumptionLimitResponse& operator=(const ConsumptionLimitResponse& from) { + CopyFrom(from); + return *this; + } + inline ConsumptionLimitResponse& operator=(ConsumptionLimitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ConsumptionLimitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const ConsumptionLimitResponse* internal_default_instance() { + return reinterpret_cast( + &_ConsumptionLimitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(ConsumptionLimitResponse& a, ConsumptionLimitResponse& b) { a.Swap(&b); } + inline void Swap(ConsumptionLimitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ConsumptionLimitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConsumptionLimitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ConsumptionLimitResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ConsumptionLimitResponse& from) { ConsumptionLimitResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ConsumptionLimitResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.ConsumptionLimitResponse"; } + + protected: + explicit ConsumptionLimitResponse(::google::protobuf::Arena* arena); + ConsumptionLimitResponse(::google::protobuf::Arena* arena, const ConsumptionLimitResponse& from); + ConsumptionLimitResponse(::google::protobuf::Arena* arena, ConsumptionLimitResponse&& from) noexcept + : ConsumptionLimitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kLoadLimitFieldNumber = 1, + }; + // .common_types.LoadLimit load_limit = 1; + bool has_load_limit() const; + void clear_load_limit() ; + const ::common_types::LoadLimit& load_limit() const; + PROTOBUF_NODISCARD ::common_types::LoadLimit* release_load_limit(); + ::common_types::LoadLimit* mutable_load_limit(); + void set_allocated_load_limit(::common_types::LoadLimit* value); + void unsafe_arena_set_allocated_load_limit(::common_types::LoadLimit* value); + ::common_types::LoadLimit* unsafe_arena_release_load_limit(); + + private: + const ::common_types::LoadLimit& _internal_load_limit() const; + ::common_types::LoadLimit* _internal_mutable_load_limit(); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.ConsumptionLimitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 1, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ConsumptionLimitResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::common_types::LoadLimit* load_limit_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class PendingConsumptionLimitResponse final + : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:cs_lpc.PendingConsumptionLimitResponse) */ { + public: + inline PendingConsumptionLimitResponse() : PendingConsumptionLimitResponse(nullptr) {} + ~PendingConsumptionLimitResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PendingConsumptionLimitResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PendingConsumptionLimitResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PendingConsumptionLimitResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline PendingConsumptionLimitResponse(const PendingConsumptionLimitResponse& from) : PendingConsumptionLimitResponse(nullptr, from) {} + inline PendingConsumptionLimitResponse(PendingConsumptionLimitResponse&& from) noexcept + : PendingConsumptionLimitResponse(nullptr, std::move(from)) {} + inline PendingConsumptionLimitResponse& operator=(const PendingConsumptionLimitResponse& from) { + CopyFrom(from); + return *this; + } + inline PendingConsumptionLimitResponse& operator=(PendingConsumptionLimitResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PendingConsumptionLimitResponse& default_instance() { + return *internal_default_instance(); + } + static inline const PendingConsumptionLimitResponse* internal_default_instance() { + return reinterpret_cast( + &_PendingConsumptionLimitResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(PendingConsumptionLimitResponse& a, PendingConsumptionLimitResponse& b) { a.Swap(&b); } + inline void Swap(PendingConsumptionLimitResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PendingConsumptionLimitResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PendingConsumptionLimitResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const PendingConsumptionLimitResponse& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const PendingConsumptionLimitResponse& from) { PendingConsumptionLimitResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl( + ::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PendingConsumptionLimitResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "cs_lpc.PendingConsumptionLimitResponse"; } + + protected: + explicit PendingConsumptionLimitResponse(::google::protobuf::Arena* arena); + PendingConsumptionLimitResponse(::google::protobuf::Arena* arena, const PendingConsumptionLimitResponse& from); + PendingConsumptionLimitResponse(::google::protobuf::Arena* arena, PendingConsumptionLimitResponse&& from) noexcept + : PendingConsumptionLimitResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataFull _class_data_; + + public: + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kLoadLimitsFieldNumber = 1, + }; + // map load_limits = 1; + int load_limits_size() const; + private: + int _internal_load_limits_size() const; + + public: + void clear_load_limits() ; + const ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>& load_limits() const; + ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>* mutable_load_limits(); + + private: + const ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>& _internal_load_limits() const; + ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>* _internal_mutable_load_limits(); + + public: + // @@protoc_insertion_point(class_scope:cs_lpc.PendingConsumptionLimitResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 2, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const PendingConsumptionLimitResponse& from_msg); + ::google::protobuf::internal::MapField + load_limits_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_usecases_2fcs_2flpc_2fmessages_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ConsumptionLimitRequest + +// ------------------------------------------------------------------- + +// ConsumptionLimitResponse + +// .common_types.LoadLimit load_limit = 1; +inline bool ConsumptionLimitResponse::has_load_limit() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.load_limit_ != nullptr); + return value; +} +inline const ::common_types::LoadLimit& ConsumptionLimitResponse::_internal_load_limit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::LoadLimit* p = _impl_.load_limit_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_LoadLimit_default_instance_); +} +inline const ::common_types::LoadLimit& ConsumptionLimitResponse::load_limit() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:cs_lpc.ConsumptionLimitResponse.load_limit) + return _internal_load_limit(); +} +inline void ConsumptionLimitResponse::unsafe_arena_set_allocated_load_limit(::common_types::LoadLimit* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.load_limit_); + } + _impl_.load_limit_ = reinterpret_cast<::common_types::LoadLimit*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:cs_lpc.ConsumptionLimitResponse.load_limit) +} +inline ::common_types::LoadLimit* ConsumptionLimitResponse::release_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::LoadLimit* released = _impl_.load_limit_; + _impl_.load_limit_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::LoadLimit* ConsumptionLimitResponse::unsafe_arena_release_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:cs_lpc.ConsumptionLimitResponse.load_limit) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::LoadLimit* temp = _impl_.load_limit_; + _impl_.load_limit_ = nullptr; + return temp; +} +inline ::common_types::LoadLimit* ConsumptionLimitResponse::_internal_mutable_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.load_limit_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::LoadLimit>(GetArena()); + _impl_.load_limit_ = reinterpret_cast<::common_types::LoadLimit*>(p); + } + return _impl_.load_limit_; +} +inline ::common_types::LoadLimit* ConsumptionLimitResponse::mutable_load_limit() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::LoadLimit* _msg = _internal_mutable_load_limit(); + // @@protoc_insertion_point(field_mutable:cs_lpc.ConsumptionLimitResponse.load_limit) + return _msg; +} +inline void ConsumptionLimitResponse::set_allocated_load_limit(::common_types::LoadLimit* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.load_limit_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.load_limit_ = reinterpret_cast<::common_types::LoadLimit*>(value); + // @@protoc_insertion_point(field_set_allocated:cs_lpc.ConsumptionLimitResponse.load_limit) +} + +// ------------------------------------------------------------------- + +// SetConsumptionLimitRequest + +// .common_types.LoadLimit load_limit = 1; +inline bool SetConsumptionLimitRequest::has_load_limit() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.load_limit_ != nullptr); + return value; +} +inline const ::common_types::LoadLimit& SetConsumptionLimitRequest::_internal_load_limit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::common_types::LoadLimit* p = _impl_.load_limit_; + return p != nullptr ? *p : reinterpret_cast(::common_types::_LoadLimit_default_instance_); +} +inline const ::common_types::LoadLimit& SetConsumptionLimitRequest::load_limit() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:cs_lpc.SetConsumptionLimitRequest.load_limit) + return _internal_load_limit(); +} +inline void SetConsumptionLimitRequest::unsafe_arena_set_allocated_load_limit(::common_types::LoadLimit* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.load_limit_); + } + _impl_.load_limit_ = reinterpret_cast<::common_types::LoadLimit*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:cs_lpc.SetConsumptionLimitRequest.load_limit) +} +inline ::common_types::LoadLimit* SetConsumptionLimitRequest::release_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::LoadLimit* released = _impl_.load_limit_; + _impl_.load_limit_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::common_types::LoadLimit* SetConsumptionLimitRequest::unsafe_arena_release_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:cs_lpc.SetConsumptionLimitRequest.load_limit) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::common_types::LoadLimit* temp = _impl_.load_limit_; + _impl_.load_limit_ = nullptr; + return temp; +} +inline ::common_types::LoadLimit* SetConsumptionLimitRequest::_internal_mutable_load_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.load_limit_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::common_types::LoadLimit>(GetArena()); + _impl_.load_limit_ = reinterpret_cast<::common_types::LoadLimit*>(p); + } + return _impl_.load_limit_; +} +inline ::common_types::LoadLimit* SetConsumptionLimitRequest::mutable_load_limit() ABSL_ATTRIBUTE_LIFETIME_BOUND { + _impl_._has_bits_[0] |= 0x00000001u; + ::common_types::LoadLimit* _msg = _internal_mutable_load_limit(); + // @@protoc_insertion_point(field_mutable:cs_lpc.SetConsumptionLimitRequest.load_limit) + return _msg; +} +inline void SetConsumptionLimitRequest::set_allocated_load_limit(::common_types::LoadLimit* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.load_limit_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.load_limit_ = reinterpret_cast<::common_types::LoadLimit*>(value); + // @@protoc_insertion_point(field_set_allocated:cs_lpc.SetConsumptionLimitRequest.load_limit) +} + +// ------------------------------------------------------------------- + +// SetConsumptionLimitResponse + +// ------------------------------------------------------------------- + +// PendingConsumptionLimitRequest + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// PendingConsumptionLimitResponse + +// map load_limits = 1; +inline int PendingConsumptionLimitResponse::_internal_load_limits_size() const { + return _internal_load_limits().size(); +} +inline int PendingConsumptionLimitResponse::load_limits_size() const { + return _internal_load_limits_size(); +} +inline const ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>& PendingConsumptionLimitResponse::_internal_load_limits() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.load_limits_.GetMap(); +} +inline const ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>& PendingConsumptionLimitResponse::load_limits() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_map:cs_lpc.PendingConsumptionLimitResponse.load_limits) + return _internal_load_limits(); +} +inline ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>* PendingConsumptionLimitResponse::_internal_mutable_load_limits() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.load_limits_.MutableMap(); +} +inline ::google::protobuf::Map<::uint64_t, ::common_types::LoadLimit>* PendingConsumptionLimitResponse::mutable_load_limits() ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_map:cs_lpc.PendingConsumptionLimitResponse.load_limits) + return _internal_mutable_load_limits(); +} + +// ------------------------------------------------------------------- + +// ApproveOrDenyConsumptionLimitRequest + +// uint64 msg_counter = 1; +inline void ApproveOrDenyConsumptionLimitRequest::clear_msg_counter() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.msg_counter_ = ::uint64_t{0u}; +} +inline ::uint64_t ApproveOrDenyConsumptionLimitRequest::msg_counter() const { + // @@protoc_insertion_point(field_get:cs_lpc.ApproveOrDenyConsumptionLimitRequest.msg_counter) + return _internal_msg_counter(); +} +inline void ApproveOrDenyConsumptionLimitRequest::set_msg_counter(::uint64_t value) { + _internal_set_msg_counter(value); + // @@protoc_insertion_point(field_set:cs_lpc.ApproveOrDenyConsumptionLimitRequest.msg_counter) +} +inline ::uint64_t ApproveOrDenyConsumptionLimitRequest::_internal_msg_counter() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.msg_counter_; +} +inline void ApproveOrDenyConsumptionLimitRequest::_internal_set_msg_counter(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.msg_counter_ = value; +} + +// bool approve = 2; +inline void ApproveOrDenyConsumptionLimitRequest::clear_approve() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.approve_ = false; +} +inline bool ApproveOrDenyConsumptionLimitRequest::approve() const { + // @@protoc_insertion_point(field_get:cs_lpc.ApproveOrDenyConsumptionLimitRequest.approve) + return _internal_approve(); +} +inline void ApproveOrDenyConsumptionLimitRequest::set_approve(bool value) { + _internal_set_approve(value); + // @@protoc_insertion_point(field_set:cs_lpc.ApproveOrDenyConsumptionLimitRequest.approve) +} +inline bool ApproveOrDenyConsumptionLimitRequest::_internal_approve() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.approve_; +} +inline void ApproveOrDenyConsumptionLimitRequest::_internal_set_approve(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.approve_ = value; +} + +// string reason = 3; +inline void ApproveOrDenyConsumptionLimitRequest::clear_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reason_.ClearToEmpty(); +} +inline const std::string& ApproveOrDenyConsumptionLimitRequest::reason() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:cs_lpc.ApproveOrDenyConsumptionLimitRequest.reason) + return _internal_reason(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ApproveOrDenyConsumptionLimitRequest::set_reason(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reason_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:cs_lpc.ApproveOrDenyConsumptionLimitRequest.reason) +} +inline std::string* ApproveOrDenyConsumptionLimitRequest::mutable_reason() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_reason(); + // @@protoc_insertion_point(field_mutable:cs_lpc.ApproveOrDenyConsumptionLimitRequest.reason) + return _s; +} +inline const std::string& ApproveOrDenyConsumptionLimitRequest::_internal_reason() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reason_.Get(); +} +inline void ApproveOrDenyConsumptionLimitRequest::_internal_set_reason(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reason_.Set(value, GetArena()); +} +inline std::string* ApproveOrDenyConsumptionLimitRequest::_internal_mutable_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.reason_.Mutable( GetArena()); +} +inline std::string* ApproveOrDenyConsumptionLimitRequest::release_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:cs_lpc.ApproveOrDenyConsumptionLimitRequest.reason) + return _impl_.reason_.Release(); +} +inline void ApproveOrDenyConsumptionLimitRequest::set_allocated_reason(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reason_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.reason_.IsDefault()) { + _impl_.reason_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:cs_lpc.ApproveOrDenyConsumptionLimitRequest.reason) +} + +// ------------------------------------------------------------------- + +// ApproveOrDenyConsumptionLimitResponse + +// ------------------------------------------------------------------- + +// FailsafeConsumptionActivePowerLimitRequest + +// ------------------------------------------------------------------- + +// FailsafeConsumptionActivePowerLimitResponse + +// double limit = 1; +inline void FailsafeConsumptionActivePowerLimitResponse::clear_limit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.limit_ = 0; +} +inline double FailsafeConsumptionActivePowerLimitResponse::limit() const { + // @@protoc_insertion_point(field_get:cs_lpc.FailsafeConsumptionActivePowerLimitResponse.limit) + return _internal_limit(); +} +inline void FailsafeConsumptionActivePowerLimitResponse::set_limit(double value) { + _internal_set_limit(value); + // @@protoc_insertion_point(field_set:cs_lpc.FailsafeConsumptionActivePowerLimitResponse.limit) +} +inline double FailsafeConsumptionActivePowerLimitResponse::_internal_limit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.limit_; +} +inline void FailsafeConsumptionActivePowerLimitResponse::_internal_set_limit(double value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.limit_ = value; +} + +// bool is_changeable = 2; +inline void FailsafeConsumptionActivePowerLimitResponse::clear_is_changeable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = false; +} +inline bool FailsafeConsumptionActivePowerLimitResponse::is_changeable() const { + // @@protoc_insertion_point(field_get:cs_lpc.FailsafeConsumptionActivePowerLimitResponse.is_changeable) + return _internal_is_changeable(); +} +inline void FailsafeConsumptionActivePowerLimitResponse::set_is_changeable(bool value) { + _internal_set_is_changeable(value); + // @@protoc_insertion_point(field_set:cs_lpc.FailsafeConsumptionActivePowerLimitResponse.is_changeable) +} +inline bool FailsafeConsumptionActivePowerLimitResponse::_internal_is_changeable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_changeable_; +} +inline void FailsafeConsumptionActivePowerLimitResponse::_internal_set_is_changeable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = value; +} + +// ------------------------------------------------------------------- + +// SetFailsafeConsumptionActivePowerLimitRequest + +// double value = 1; +inline void SetFailsafeConsumptionActivePowerLimitRequest::clear_value() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = 0; +} +inline double SetFailsafeConsumptionActivePowerLimitRequest::value() const { + // @@protoc_insertion_point(field_get:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest.value) + return _internal_value(); +} +inline void SetFailsafeConsumptionActivePowerLimitRequest::set_value(double value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest.value) +} +inline double SetFailsafeConsumptionActivePowerLimitRequest::_internal_value() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.value_; +} +inline void SetFailsafeConsumptionActivePowerLimitRequest::_internal_set_value(double value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = value; +} + +// bool is_changeable = 2; +inline void SetFailsafeConsumptionActivePowerLimitRequest::clear_is_changeable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = false; +} +inline bool SetFailsafeConsumptionActivePowerLimitRequest::is_changeable() const { + // @@protoc_insertion_point(field_get:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest.is_changeable) + return _internal_is_changeable(); +} +inline void SetFailsafeConsumptionActivePowerLimitRequest::set_is_changeable(bool value) { + _internal_set_is_changeable(value); + // @@protoc_insertion_point(field_set:cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest.is_changeable) +} +inline bool SetFailsafeConsumptionActivePowerLimitRequest::_internal_is_changeable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_changeable_; +} +inline void SetFailsafeConsumptionActivePowerLimitRequest::_internal_set_is_changeable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = value; +} + +// ------------------------------------------------------------------- + +// SetFailsafeConsumptionActivePowerLimitResponse + +// ------------------------------------------------------------------- + +// FailsafeDurationMinimumRequest + +// ------------------------------------------------------------------- + +// FailsafeDurationMinimumResponse + +// int64 duration_nanoseconds = 1; +inline void FailsafeDurationMinimumResponse::clear_duration_nanoseconds() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_nanoseconds_ = ::int64_t{0}; +} +inline ::int64_t FailsafeDurationMinimumResponse::duration_nanoseconds() const { + // @@protoc_insertion_point(field_get:cs_lpc.FailsafeDurationMinimumResponse.duration_nanoseconds) + return _internal_duration_nanoseconds(); +} +inline void FailsafeDurationMinimumResponse::set_duration_nanoseconds(::int64_t value) { + _internal_set_duration_nanoseconds(value); + // @@protoc_insertion_point(field_set:cs_lpc.FailsafeDurationMinimumResponse.duration_nanoseconds) +} +inline ::int64_t FailsafeDurationMinimumResponse::_internal_duration_nanoseconds() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.duration_nanoseconds_; +} +inline void FailsafeDurationMinimumResponse::_internal_set_duration_nanoseconds(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_nanoseconds_ = value; +} + +// bool is_changeable = 2; +inline void FailsafeDurationMinimumResponse::clear_is_changeable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = false; +} +inline bool FailsafeDurationMinimumResponse::is_changeable() const { + // @@protoc_insertion_point(field_get:cs_lpc.FailsafeDurationMinimumResponse.is_changeable) + return _internal_is_changeable(); +} +inline void FailsafeDurationMinimumResponse::set_is_changeable(bool value) { + _internal_set_is_changeable(value); + // @@protoc_insertion_point(field_set:cs_lpc.FailsafeDurationMinimumResponse.is_changeable) +} +inline bool FailsafeDurationMinimumResponse::_internal_is_changeable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_changeable_; +} +inline void FailsafeDurationMinimumResponse::_internal_set_is_changeable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = value; +} + +// ------------------------------------------------------------------- + +// SetFailsafeDurationMinimumRequest + +// int64 duration_nanoseconds = 1; +inline void SetFailsafeDurationMinimumRequest::clear_duration_nanoseconds() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_nanoseconds_ = ::int64_t{0}; +} +inline ::int64_t SetFailsafeDurationMinimumRequest::duration_nanoseconds() const { + // @@protoc_insertion_point(field_get:cs_lpc.SetFailsafeDurationMinimumRequest.duration_nanoseconds) + return _internal_duration_nanoseconds(); +} +inline void SetFailsafeDurationMinimumRequest::set_duration_nanoseconds(::int64_t value) { + _internal_set_duration_nanoseconds(value); + // @@protoc_insertion_point(field_set:cs_lpc.SetFailsafeDurationMinimumRequest.duration_nanoseconds) +} +inline ::int64_t SetFailsafeDurationMinimumRequest::_internal_duration_nanoseconds() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.duration_nanoseconds_; +} +inline void SetFailsafeDurationMinimumRequest::_internal_set_duration_nanoseconds(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_nanoseconds_ = value; +} + +// bool is_changeable = 2; +inline void SetFailsafeDurationMinimumRequest::clear_is_changeable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = false; +} +inline bool SetFailsafeDurationMinimumRequest::is_changeable() const { + // @@protoc_insertion_point(field_get:cs_lpc.SetFailsafeDurationMinimumRequest.is_changeable) + return _internal_is_changeable(); +} +inline void SetFailsafeDurationMinimumRequest::set_is_changeable(bool value) { + _internal_set_is_changeable(value); + // @@protoc_insertion_point(field_set:cs_lpc.SetFailsafeDurationMinimumRequest.is_changeable) +} +inline bool SetFailsafeDurationMinimumRequest::_internal_is_changeable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_changeable_; +} +inline void SetFailsafeDurationMinimumRequest::_internal_set_is_changeable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_changeable_ = value; +} + +// ------------------------------------------------------------------- + +// SetFailsafeDurationMinimumResponse + +// ------------------------------------------------------------------- + +// StartHeartbeatRequest + +// ------------------------------------------------------------------- + +// StartHeartbeatResponse + +// ------------------------------------------------------------------- + +// StopHeartbeatRequest + +// ------------------------------------------------------------------- + +// StopHeartbeatResponse + +// ------------------------------------------------------------------- + +// IsHeartbeatWithinDurationRequest + +// ------------------------------------------------------------------- + +// IsHeartbeatWithinDurationResponse + +// bool is_within_duration = 1; +inline void IsHeartbeatWithinDurationResponse::clear_is_within_duration() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_within_duration_ = false; +} +inline bool IsHeartbeatWithinDurationResponse::is_within_duration() const { + // @@protoc_insertion_point(field_get:cs_lpc.IsHeartbeatWithinDurationResponse.is_within_duration) + return _internal_is_within_duration(); +} +inline void IsHeartbeatWithinDurationResponse::set_is_within_duration(bool value) { + _internal_set_is_within_duration(value); + // @@protoc_insertion_point(field_set:cs_lpc.IsHeartbeatWithinDurationResponse.is_within_duration) +} +inline bool IsHeartbeatWithinDurationResponse::_internal_is_within_duration() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.is_within_duration_; +} +inline void IsHeartbeatWithinDurationResponse::_internal_set_is_within_duration(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.is_within_duration_ = value; +} + +// ------------------------------------------------------------------- + +// ConsumptionNominalMaxRequest + +// ------------------------------------------------------------------- + +// ConsumptionNominalMaxResponse + +// double value = 1; +inline void ConsumptionNominalMaxResponse::clear_value() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = 0; +} +inline double ConsumptionNominalMaxResponse::value() const { + // @@protoc_insertion_point(field_get:cs_lpc.ConsumptionNominalMaxResponse.value) + return _internal_value(); +} +inline void ConsumptionNominalMaxResponse::set_value(double value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:cs_lpc.ConsumptionNominalMaxResponse.value) +} +inline double ConsumptionNominalMaxResponse::_internal_value() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.value_; +} +inline void ConsumptionNominalMaxResponse::_internal_set_value(double value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = value; +} + +// ------------------------------------------------------------------- + +// SetConsumptionNominalMaxRequest + +// double value = 1; +inline void SetConsumptionNominalMaxRequest::clear_value() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = 0; +} +inline double SetConsumptionNominalMaxRequest::value() const { + // @@protoc_insertion_point(field_get:cs_lpc.SetConsumptionNominalMaxRequest.value) + return _internal_value(); +} +inline void SetConsumptionNominalMaxRequest::set_value(double value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:cs_lpc.SetConsumptionNominalMaxRequest.value) +} +inline double SetConsumptionNominalMaxRequest::_internal_value() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.value_; +} +inline void SetConsumptionNominalMaxRequest::_internal_set_value(double value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.value_ = value; +} + +// ------------------------------------------------------------------- + +// SetConsumptionNominalMaxResponse + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +ConsumptionLimitRequest CreateConsumptionLimitRequest(); + +ConsumptionLimitResponse CreateConsumptionLimitResponse( + common_types::LoadLimit* load_limit); + +SetConsumptionLimitRequest CreateSetConsumptionLimitRequest( + common_types::LoadLimit* load_limit); + +SetConsumptionLimitResponse CreateSetConsumptionLimitResponse(); + +PendingConsumptionLimitRequest CreatePendingConsumptionLimitRequest(); + +PendingConsumptionLimitResponse CreatePendingConsumptionLimitResponse( + std::map load_limits); + +ApproveOrDenyConsumptionLimitRequest CreateApproveOrDenyConsumptionLimitRequest( + uint64_t msg_counter, + bool approve, + std::string reason); + +ApproveOrDenyConsumptionLimitResponse CreateApproveOrDenyConsumptionLimitResponse(); + +FailsafeConsumptionActivePowerLimitRequest CreateFailsafeConsumptionActivePowerLimitRequest(); + +FailsafeConsumptionActivePowerLimitResponse CreateFailsafeConsumptionActivePowerLimitResponse( + double limit, + bool is_changeable); + +SetFailsafeConsumptionActivePowerLimitRequest CreateSetFailsafeConsumptionActivePowerLimitRequest( + double value, + bool is_changeable); + +SetFailsafeConsumptionActivePowerLimitResponse CreateSetFailsafeConsumptionActivePowerLimitResponse(); + +FailsafeDurationMinimumRequest CreateFailsafeDurationMinimumRequest(); + +FailsafeDurationMinimumResponse CreateFailsafeDurationMinimumResponse( + int64_t duration_nanoseconds, + bool is_changeable); + +SetFailsafeDurationMinimumRequest CreateSetFailsafeDurationMinimumRequest( + int64_t duration_nanoseconds, + bool is_changeable); + +SetFailsafeDurationMinimumResponse CreateSetFailsafeDurationMinimumResponse(); + +StartHeartbeatRequest CreateStartHeartbeatRequest(); + +StartHeartbeatResponse CreateStartHeartbeatResponse(); + +StopHeartbeatRequest CreateStopHeartbeatRequest(); + +StopHeartbeatResponse CreateStopHeartbeatResponse(); + +IsHeartbeatWithinDurationRequest CreateIsHeartbeatWithinDurationRequest(); + +IsHeartbeatWithinDurationResponse CreateIsHeartbeatWithinDurationResponse( + bool is_within_duration); + +ConsumptionNominalMaxRequest CreateConsumptionNominalMaxRequest(); + +ConsumptionNominalMaxResponse CreateConsumptionNominalMaxResponse( + double value); + +SetConsumptionNominalMaxRequest CreateSetConsumptionNominalMaxRequest( + double value); + +SetConsumptionNominalMaxResponse CreateSetConsumptionNominalMaxResponse(); + +// @@protoc_insertion_point(namespace_scope) +} // namespace cs_lpc + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // usecases_2fcs_2flpc_2fmessages_2eproto_2epb_2eh diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.cc new file mode 100644 index 0000000000..6c9d504b39 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.cc @@ -0,0 +1,295 @@ +#include "usecases/cs/lpc/service.grpc-ext.pb.h" + +#include +#include + +namespace cs_lpc { + +grpc::Status CallConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::ConsumptionLimitRequest& request, + cs_lpc::ConsumptionLimitResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->ConsumptionLimit( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallSetConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::SetConsumptionLimitRequest& request, + cs_lpc::SetConsumptionLimitResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->SetConsumptionLimit( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallPendingConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::PendingConsumptionLimitRequest& request, + cs_lpc::PendingConsumptionLimitResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->PendingConsumptionLimit( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallApproveOrDenyConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, + cs_lpc::ApproveOrDenyConsumptionLimitResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->ApproveOrDenyConsumptionLimit( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallFailsafeConsumptionActivePowerLimit( + const std::shared_ptr &stub, + cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, + cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->FailsafeConsumptionActivePowerLimit( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallSetFailsafeConsumptionActivePowerLimit( + const std::shared_ptr &stub, + cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, + cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->SetFailsafeConsumptionActivePowerLimit( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallFailsafeDurationMinimum( + const std::shared_ptr &stub, + cs_lpc::FailsafeDurationMinimumRequest& request, + cs_lpc::FailsafeDurationMinimumResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->FailsafeDurationMinimum( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallSetFailsafeDurationMinimum( + const std::shared_ptr &stub, + cs_lpc::SetFailsafeDurationMinimumRequest& request, + cs_lpc::SetFailsafeDurationMinimumResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->SetFailsafeDurationMinimum( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallStartHeartbeat( + const std::shared_ptr &stub, + cs_lpc::StartHeartbeatRequest& request, + cs_lpc::StartHeartbeatResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->StartHeartbeat( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallStopHeartbeat( + const std::shared_ptr &stub, + cs_lpc::StopHeartbeatRequest& request, + cs_lpc::StopHeartbeatResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->StopHeartbeat( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallIsHeartbeatWithinDuration( + const std::shared_ptr &stub, + cs_lpc::IsHeartbeatWithinDurationRequest& request, + cs_lpc::IsHeartbeatWithinDurationResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->IsHeartbeatWithinDuration( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallConsumptionNominalMax( + const std::shared_ptr &stub, + cs_lpc::ConsumptionNominalMaxRequest& request, + cs_lpc::ConsumptionNominalMaxResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->ConsumptionNominalMax( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +grpc::Status CallSetConsumptionNominalMax( + const std::shared_ptr &stub, + cs_lpc::SetConsumptionNominalMaxRequest& request, + cs_lpc::SetConsumptionNominalMaxResponse* response) { + grpc::ClientContext context; + grpc::Status result; + bool done = false; + std::mutex mu; + std::condition_variable cv; + stub->async()->SetConsumptionNominalMax( + &context, &request, response, + [&result, &mu, &cv, &done, response](grpc::Status status) { + result = std::move(status); + std::lock_guard lock(mu); + done = true; + cv.notify_one(); + }); + std::unique_lock lock(mu); + cv.wait(lock, [&done] { return done; }); + return result; +} + +} // namespace cs_lpc + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.h new file mode 100644 index 0000000000..5f91be6696 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.h @@ -0,0 +1,76 @@ +#ifndef GENERATED_usecases_cs_lpc_service_proto_EXT_H +#define GENERATED_usecases_cs_lpc_service_proto_EXT_H + +#include "usecases/cs/lpc/service.grpc.pb.h" +#include "usecases/cs/lpc/messages.grpc-ext.pb.h" + +namespace cs_lpc { + +grpc::Status CallConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::ConsumptionLimitRequest& request, + cs_lpc::ConsumptionLimitResponse* response); + +grpc::Status CallSetConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::SetConsumptionLimitRequest& request, + cs_lpc::SetConsumptionLimitResponse* response); + +grpc::Status CallPendingConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::PendingConsumptionLimitRequest& request, + cs_lpc::PendingConsumptionLimitResponse* response); + +grpc::Status CallApproveOrDenyConsumptionLimit( + const std::shared_ptr &stub, + cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, + cs_lpc::ApproveOrDenyConsumptionLimitResponse* response); + +grpc::Status CallFailsafeConsumptionActivePowerLimit( + const std::shared_ptr &stub, + cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, + cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response); + +grpc::Status CallSetFailsafeConsumptionActivePowerLimit( + const std::shared_ptr &stub, + cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, + cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response); + +grpc::Status CallFailsafeDurationMinimum( + const std::shared_ptr &stub, + cs_lpc::FailsafeDurationMinimumRequest& request, + cs_lpc::FailsafeDurationMinimumResponse* response); + +grpc::Status CallSetFailsafeDurationMinimum( + const std::shared_ptr &stub, + cs_lpc::SetFailsafeDurationMinimumRequest& request, + cs_lpc::SetFailsafeDurationMinimumResponse* response); + +grpc::Status CallStartHeartbeat( + const std::shared_ptr &stub, + cs_lpc::StartHeartbeatRequest& request, + cs_lpc::StartHeartbeatResponse* response); + +grpc::Status CallStopHeartbeat( + const std::shared_ptr &stub, + cs_lpc::StopHeartbeatRequest& request, + cs_lpc::StopHeartbeatResponse* response); + +grpc::Status CallIsHeartbeatWithinDuration( + const std::shared_ptr &stub, + cs_lpc::IsHeartbeatWithinDurationRequest& request, + cs_lpc::IsHeartbeatWithinDurationResponse* response); + +grpc::Status CallConsumptionNominalMax( + const std::shared_ptr &stub, + cs_lpc::ConsumptionNominalMaxRequest& request, + cs_lpc::ConsumptionNominalMaxResponse* response); + +grpc::Status CallSetConsumptionNominalMax( + const std::shared_ptr &stub, + cs_lpc::SetConsumptionNominalMaxRequest& request, + cs_lpc::SetConsumptionNominalMaxResponse* response); + +} // namespace cs_lpc + +#endif // GENERATED_usecases_cs_lpc_service_proto_EXT_H diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.cc new file mode 100644 index 0000000000..c24f89570e --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.cc @@ -0,0 +1,590 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: usecases/cs/lpc/service.proto + +#include "usecases/cs/lpc/service.pb.h" +#include "usecases/cs/lpc/service.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace cs_lpc { + +static const char* ControllableSystemLPCControl_method_names[] = { + "/cs_lpc.ControllableSystemLPCControl/ConsumptionLimit", + "/cs_lpc.ControllableSystemLPCControl/SetConsumptionLimit", + "/cs_lpc.ControllableSystemLPCControl/PendingConsumptionLimit", + "/cs_lpc.ControllableSystemLPCControl/ApproveOrDenyConsumptionLimit", + "/cs_lpc.ControllableSystemLPCControl/FailsafeConsumptionActivePowerLimit", + "/cs_lpc.ControllableSystemLPCControl/SetFailsafeConsumptionActivePowerLimit", + "/cs_lpc.ControllableSystemLPCControl/FailsafeDurationMinimum", + "/cs_lpc.ControllableSystemLPCControl/SetFailsafeDurationMinimum", + "/cs_lpc.ControllableSystemLPCControl/StartHeartbeat", + "/cs_lpc.ControllableSystemLPCControl/StopHeartbeat", + "/cs_lpc.ControllableSystemLPCControl/IsHeartbeatWithinDuration", + "/cs_lpc.ControllableSystemLPCControl/ConsumptionNominalMax", + "/cs_lpc.ControllableSystemLPCControl/SetConsumptionNominalMax", +}; + +std::unique_ptr< ControllableSystemLPCControl::Stub> ControllableSystemLPCControl::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< ControllableSystemLPCControl::Stub> stub(new ControllableSystemLPCControl::Stub(channel, options)); + return stub; +} + +ControllableSystemLPCControl::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_ConsumptionLimit_(ControllableSystemLPCControl_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SetConsumptionLimit_(ControllableSystemLPCControl_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PendingConsumptionLimit_(ControllableSystemLPCControl_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ApproveOrDenyConsumptionLimit_(ControllableSystemLPCControl_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_FailsafeConsumptionActivePowerLimit_(ControllableSystemLPCControl_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SetFailsafeConsumptionActivePowerLimit_(ControllableSystemLPCControl_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_FailsafeDurationMinimum_(ControllableSystemLPCControl_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SetFailsafeDurationMinimum_(ControllableSystemLPCControl_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_StartHeartbeat_(ControllableSystemLPCControl_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_StopHeartbeat_(ControllableSystemLPCControl_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_IsHeartbeatWithinDuration_(ControllableSystemLPCControl_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ConsumptionNominalMax_(ControllableSystemLPCControl_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SetConsumptionNominalMax_(ControllableSystemLPCControl_method_names[12], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status ControllableSystemLPCControl::Stub::ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::cs_lpc::ConsumptionLimitResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ConsumptionLimit_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ConsumptionLimit_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ConsumptionLimit_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::ConsumptionLimitResponse, ::cs_lpc::ConsumptionLimitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ConsumptionLimit_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::AsyncConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncConsumptionLimitRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::cs_lpc::SetConsumptionLimitResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetConsumptionLimit_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetConsumptionLimit_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetConsumptionLimit_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncSetConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::SetConsumptionLimitResponse, ::cs_lpc::SetConsumptionLimitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetConsumptionLimit_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::AsyncSetConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetConsumptionLimitRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::cs_lpc::PendingConsumptionLimitResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PendingConsumptionLimit_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PendingConsumptionLimit_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PendingConsumptionLimit_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncPendingConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::PendingConsumptionLimitResponse, ::cs_lpc::PendingConsumptionLimitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PendingConsumptionLimit_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::AsyncPendingConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncPendingConsumptionLimitRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ApproveOrDenyConsumptionLimit_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ApproveOrDenyConsumptionLimit_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ApproveOrDenyConsumptionLimit_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncApproveOrDenyConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse, ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ApproveOrDenyConsumptionLimit_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* ControllableSystemLPCControl::Stub::AsyncApproveOrDenyConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncApproveOrDenyConsumptionLimitRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_FailsafeConsumptionActivePowerLimit_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FailsafeConsumptionActivePowerLimit_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FailsafeConsumptionActivePowerLimit_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_FailsafeConsumptionActivePowerLimit_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* ControllableSystemLPCControl::Stub::AsyncFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncFailsafeConsumptionActivePowerLimitRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetFailsafeConsumptionActivePowerLimit_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetFailsafeConsumptionActivePowerLimit_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetFailsafeConsumptionActivePowerLimit_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncSetFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetFailsafeConsumptionActivePowerLimit_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* ControllableSystemLPCControl::Stub::AsyncSetFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetFailsafeConsumptionActivePowerLimitRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::cs_lpc::FailsafeDurationMinimumResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_FailsafeDurationMinimum_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FailsafeDurationMinimum_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FailsafeDurationMinimum_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::FailsafeDurationMinimumResponse, ::cs_lpc::FailsafeDurationMinimumRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_FailsafeDurationMinimum_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>* ControllableSystemLPCControl::Stub::AsyncFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncFailsafeDurationMinimumRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetFailsafeDurationMinimum_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetFailsafeDurationMinimum_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetFailsafeDurationMinimum_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncSetFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::SetFailsafeDurationMinimumResponse, ::cs_lpc::SetFailsafeDurationMinimumRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetFailsafeDurationMinimum_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>* ControllableSystemLPCControl::Stub::AsyncSetFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetFailsafeDurationMinimumRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::cs_lpc::StartHeartbeatResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartHeartbeat_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartHeartbeat_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartHeartbeat_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncStartHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::StartHeartbeatResponse, ::cs_lpc::StartHeartbeatRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartHeartbeat_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>* ControllableSystemLPCControl::Stub::AsyncStartHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStartHeartbeatRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::cs_lpc::StopHeartbeatResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StopHeartbeat_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopHeartbeat_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopHeartbeat_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncStopHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::StopHeartbeatResponse, ::cs_lpc::StopHeartbeatRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StopHeartbeat_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>* ControllableSystemLPCControl::Stub::AsyncStopHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStopHeartbeatRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_IsHeartbeatWithinDuration_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_IsHeartbeatWithinDuration_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_IsHeartbeatWithinDuration_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncIsHeartbeatWithinDurationRaw(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::IsHeartbeatWithinDurationResponse, ::cs_lpc::IsHeartbeatWithinDurationRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_IsHeartbeatWithinDuration_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>* ControllableSystemLPCControl::Stub::AsyncIsHeartbeatWithinDurationRaw(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncIsHeartbeatWithinDurationRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::cs_lpc::ConsumptionNominalMaxResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ConsumptionNominalMax_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ConsumptionNominalMax_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ConsumptionNominalMax_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::ConsumptionNominalMaxResponse, ::cs_lpc::ConsumptionNominalMaxRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ConsumptionNominalMax_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>* ControllableSystemLPCControl::Stub::AsyncConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncConsumptionNominalMaxRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ControllableSystemLPCControl::Stub::SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::cs_lpc::SetConsumptionNominalMaxResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetConsumptionNominalMax_, context, request, response); +} + +void ControllableSystemLPCControl::Stub::async::SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetConsumptionNominalMax_, context, request, response, std::move(f)); +} + +void ControllableSystemLPCControl::Stub::async::SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetConsumptionNominalMax_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>* ControllableSystemLPCControl::Stub::PrepareAsyncSetConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::cs_lpc::SetConsumptionNominalMaxResponse, ::cs_lpc::SetConsumptionNominalMaxRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetConsumptionNominalMax_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>* ControllableSystemLPCControl::Stub::AsyncSetConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetConsumptionNominalMaxRaw(context, request, cq); + result->StartCall(); + return result; +} + +ControllableSystemLPCControl::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::ConsumptionLimitRequest* req, + ::cs_lpc::ConsumptionLimitResponse* resp) { + return service->ConsumptionLimit(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[1], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::SetConsumptionLimitRequest* req, + ::cs_lpc::SetConsumptionLimitResponse* resp) { + return service->SetConsumptionLimit(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[2], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::PendingConsumptionLimitRequest* req, + ::cs_lpc::PendingConsumptionLimitResponse* resp) { + return service->PendingConsumptionLimit(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[3], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* req, + ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* resp) { + return service->ApproveOrDenyConsumptionLimit(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[4], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* req, + ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* resp) { + return service->FailsafeConsumptionActivePowerLimit(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[5], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* req, + ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* resp) { + return service->SetFailsafeConsumptionActivePowerLimit(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[6], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::FailsafeDurationMinimumRequest* req, + ::cs_lpc::FailsafeDurationMinimumResponse* resp) { + return service->FailsafeDurationMinimum(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[7], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::SetFailsafeDurationMinimumRequest* req, + ::cs_lpc::SetFailsafeDurationMinimumResponse* resp) { + return service->SetFailsafeDurationMinimum(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[8], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::StartHeartbeatRequest* req, + ::cs_lpc::StartHeartbeatResponse* resp) { + return service->StartHeartbeat(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[9], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::StopHeartbeatRequest* req, + ::cs_lpc::StopHeartbeatResponse* resp) { + return service->StopHeartbeat(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[10], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::IsHeartbeatWithinDurationRequest* req, + ::cs_lpc::IsHeartbeatWithinDurationResponse* resp) { + return service->IsHeartbeatWithinDuration(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[11], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::ConsumptionNominalMaxRequest* req, + ::cs_lpc::ConsumptionNominalMaxResponse* resp) { + return service->ConsumptionNominalMax(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ControllableSystemLPCControl_method_names[12], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ControllableSystemLPCControl::Service, ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ControllableSystemLPCControl::Service* service, + ::grpc::ServerContext* ctx, + const ::cs_lpc::SetConsumptionNominalMaxRequest* req, + ::cs_lpc::SetConsumptionNominalMaxResponse* resp) { + return service->SetConsumptionNominalMax(ctx, req, resp); + }, this))); +} + +ControllableSystemLPCControl::Service::~Service() { +} + +::grpc::Status ControllableSystemLPCControl::Service::ConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::SetConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::PendingConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::ApproveOrDenyConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::FailsafeDurationMinimum(::grpc::ServerContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::SetFailsafeDurationMinimum(::grpc::ServerContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::StartHeartbeat(::grpc::ServerContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::StopHeartbeat(::grpc::ServerContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::IsHeartbeatWithinDuration(::grpc::ServerContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::ConsumptionNominalMax(::grpc::ServerContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ControllableSystemLPCControl::Service::SetConsumptionNominalMax(::grpc::ServerContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace cs_lpc + diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.h new file mode 100644 index 0000000000..030f111bc7 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.h @@ -0,0 +1,2130 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: usecases/cs/lpc/service.proto +// Original file comments: +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +// +#ifndef GRPC_usecases_2fcs_2flpc_2fservice_2eproto__INCLUDED +#define GRPC_usecases_2fcs_2flpc_2fservice_2eproto__INCLUDED + +#include "usecases/cs/lpc/service.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace cs_lpc { + +class ControllableSystemLPCControl final { + public: + static constexpr char const* service_full_name() { + return "cs_lpc.ControllableSystemLPCControl"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + virtual ::grpc::Status ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::cs_lpc::ConsumptionLimitResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionLimitResponse>> AsyncConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionLimitResponse>>(AsyncConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionLimitResponse>> PrepareAsyncConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionLimitResponse>>(PrepareAsyncConsumptionLimitRaw(context, request, cq)); + } + virtual ::grpc::Status SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::cs_lpc::SetConsumptionLimitResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionLimitResponse>> AsyncSetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionLimitResponse>>(AsyncSetConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionLimitResponse>> PrepareAsyncSetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionLimitResponse>>(PrepareAsyncSetConsumptionLimitRaw(context, request, cq)); + } + virtual ::grpc::Status PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::cs_lpc::PendingConsumptionLimitResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::PendingConsumptionLimitResponse>> AsyncPendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::PendingConsumptionLimitResponse>>(AsyncPendingConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::PendingConsumptionLimitResponse>> PrepareAsyncPendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::PendingConsumptionLimitResponse>>(PrepareAsyncPendingConsumptionLimitRaw(context, request, cq)); + } + virtual ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>> AsyncApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>>(AsyncApproveOrDenyConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>> PrepareAsyncApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>>(PrepareAsyncApproveOrDenyConsumptionLimitRaw(context, request, cq)); + } + virtual ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>> AsyncFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>>(AsyncFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>> PrepareAsyncFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>>(PrepareAsyncFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + virtual ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>> AsyncSetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>>(AsyncSetFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>> PrepareAsyncSetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>>(PrepareAsyncSetFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + virtual ::grpc::Status FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::cs_lpc::FailsafeDurationMinimumResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeDurationMinimumResponse>> AsyncFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeDurationMinimumResponse>>(AsyncFailsafeDurationMinimumRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeDurationMinimumResponse>> PrepareAsyncFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeDurationMinimumResponse>>(PrepareAsyncFailsafeDurationMinimumRaw(context, request, cq)); + } + virtual ::grpc::Status SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeDurationMinimumResponse>> AsyncSetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeDurationMinimumResponse>>(AsyncSetFailsafeDurationMinimumRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeDurationMinimumResponse>> PrepareAsyncSetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeDurationMinimumResponse>>(PrepareAsyncSetFailsafeDurationMinimumRaw(context, request, cq)); + } + virtual ::grpc::Status StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::cs_lpc::StartHeartbeatResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StartHeartbeatResponse>> AsyncStartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StartHeartbeatResponse>>(AsyncStartHeartbeatRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StartHeartbeatResponse>> PrepareAsyncStartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StartHeartbeatResponse>>(PrepareAsyncStartHeartbeatRaw(context, request, cq)); + } + virtual ::grpc::Status StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::cs_lpc::StopHeartbeatResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StopHeartbeatResponse>> AsyncStopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StopHeartbeatResponse>>(AsyncStopHeartbeatRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StopHeartbeatResponse>> PrepareAsyncStopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StopHeartbeatResponse>>(PrepareAsyncStopHeartbeatRaw(context, request, cq)); + } + virtual ::grpc::Status IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::IsHeartbeatWithinDurationResponse>> AsyncIsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::IsHeartbeatWithinDurationResponse>>(AsyncIsHeartbeatWithinDurationRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::IsHeartbeatWithinDurationResponse>> PrepareAsyncIsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::IsHeartbeatWithinDurationResponse>>(PrepareAsyncIsHeartbeatWithinDurationRaw(context, request, cq)); + } + virtual ::grpc::Status ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::cs_lpc::ConsumptionNominalMaxResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionNominalMaxResponse>> AsyncConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionNominalMaxResponse>>(AsyncConsumptionNominalMaxRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionNominalMaxResponse>> PrepareAsyncConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionNominalMaxResponse>>(PrepareAsyncConsumptionNominalMaxRaw(context, request, cq)); + } + virtual ::grpc::Status SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::cs_lpc::SetConsumptionNominalMaxResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionNominalMaxResponse>> AsyncSetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionNominalMaxResponse>>(AsyncSetConsumptionNominalMaxRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionNominalMaxResponse>> PrepareAsyncSetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionNominalMaxResponse>>(PrepareAsyncSetConsumptionNominalMaxRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + virtual void ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response, std::function) = 0; + virtual void ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response, std::function) = 0; + virtual void SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response, std::function) = 0; + virtual void PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response, std::function) = 0; + virtual void ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response, std::function) = 0; + virtual void FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response, std::function) = 0; + virtual void SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response, std::function) = 0; + virtual void FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response, std::function) = 0; + virtual void SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response, std::function) = 0; + virtual void StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response, std::function) = 0; + virtual void StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response, std::function) = 0; + virtual void IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response, std::function) = 0; + virtual void ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response, std::function) = 0; + virtual void SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionLimitResponse>* AsyncConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionLimitResponse>* PrepareAsyncConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionLimitResponse>* AsyncSetConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionLimitResponse>* PrepareAsyncSetConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::PendingConsumptionLimitResponse>* AsyncPendingConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::PendingConsumptionLimitResponse>* PrepareAsyncPendingConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* AsyncApproveOrDenyConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* PrepareAsyncApproveOrDenyConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* AsyncFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* PrepareAsyncFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* AsyncSetFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* PrepareAsyncSetFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeDurationMinimumResponse>* AsyncFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::FailsafeDurationMinimumResponse>* PrepareAsyncFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeDurationMinimumResponse>* AsyncSetFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetFailsafeDurationMinimumResponse>* PrepareAsyncSetFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StartHeartbeatResponse>* AsyncStartHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StartHeartbeatResponse>* PrepareAsyncStartHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StopHeartbeatResponse>* AsyncStopHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::StopHeartbeatResponse>* PrepareAsyncStopHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::IsHeartbeatWithinDurationResponse>* AsyncIsHeartbeatWithinDurationRaw(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::IsHeartbeatWithinDurationResponse>* PrepareAsyncIsHeartbeatWithinDurationRaw(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionNominalMaxResponse>* AsyncConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::ConsumptionNominalMaxResponse>* PrepareAsyncConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionNominalMaxResponse>* AsyncSetConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::cs_lpc::SetConsumptionNominalMaxResponse>* PrepareAsyncSetConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::cs_lpc::ConsumptionLimitResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>> AsyncConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>>(AsyncConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>> PrepareAsyncConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>>(PrepareAsyncConsumptionLimitRaw(context, request, cq)); + } + ::grpc::Status SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::cs_lpc::SetConsumptionLimitResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>> AsyncSetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>>(AsyncSetConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>> PrepareAsyncSetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>>(PrepareAsyncSetConsumptionLimitRaw(context, request, cq)); + } + ::grpc::Status PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::cs_lpc::PendingConsumptionLimitResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>> AsyncPendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>>(AsyncPendingConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>> PrepareAsyncPendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>>(PrepareAsyncPendingConsumptionLimitRaw(context, request, cq)); + } + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>> AsyncApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>>(AsyncApproveOrDenyConsumptionLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>> PrepareAsyncApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>>(PrepareAsyncApproveOrDenyConsumptionLimitRaw(context, request, cq)); + } + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>> AsyncFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>>(AsyncFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>> PrepareAsyncFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>>(PrepareAsyncFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>> AsyncSetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>>(AsyncSetFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>> PrepareAsyncSetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>>(PrepareAsyncSetFailsafeConsumptionActivePowerLimitRaw(context, request, cq)); + } + ::grpc::Status FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::cs_lpc::FailsafeDurationMinimumResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>> AsyncFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>>(AsyncFailsafeDurationMinimumRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>> PrepareAsyncFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>>(PrepareAsyncFailsafeDurationMinimumRaw(context, request, cq)); + } + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>> AsyncSetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>>(AsyncSetFailsafeDurationMinimumRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>> PrepareAsyncSetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>>(PrepareAsyncSetFailsafeDurationMinimumRaw(context, request, cq)); + } + ::grpc::Status StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::cs_lpc::StartHeartbeatResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>> AsyncStartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>>(AsyncStartHeartbeatRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>> PrepareAsyncStartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>>(PrepareAsyncStartHeartbeatRaw(context, request, cq)); + } + ::grpc::Status StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::cs_lpc::StopHeartbeatResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>> AsyncStopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>>(AsyncStopHeartbeatRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>> PrepareAsyncStopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>>(PrepareAsyncStopHeartbeatRaw(context, request, cq)); + } + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>> AsyncIsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>>(AsyncIsHeartbeatWithinDurationRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>> PrepareAsyncIsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>>(PrepareAsyncIsHeartbeatWithinDurationRaw(context, request, cq)); + } + ::grpc::Status ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::cs_lpc::ConsumptionNominalMaxResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>> AsyncConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>>(AsyncConsumptionNominalMaxRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>> PrepareAsyncConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>>(PrepareAsyncConsumptionNominalMaxRaw(context, request, cq)); + } + ::grpc::Status SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::cs_lpc::SetConsumptionNominalMaxResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>> AsyncSetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>>(AsyncSetConsumptionNominalMaxRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>> PrepareAsyncSetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>>(PrepareAsyncSetConsumptionNominalMaxRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response, std::function) override; + void ConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response, std::function) override; + void SetConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response, std::function) override; + void PendingConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response, std::function) override; + void ApproveOrDenyConsumptionLimit(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response, std::function) override; + void FailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response, std::function) override; + void SetFailsafeConsumptionActivePowerLimit(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response, std::function) override; + void FailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response, std::function) override; + void SetFailsafeDurationMinimum(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response, std::function) override; + void StartHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response, std::function) override; + void StopHeartbeat(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response, std::function) override; + void IsHeartbeatWithinDuration(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response, std::function) override; + void ConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response, std::function) override; + void SetConsumptionNominalMax(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>* AsyncConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionLimitResponse>* PrepareAsyncConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>* AsyncSetConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionLimitResponse>* PrepareAsyncSetConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>* AsyncPendingConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::PendingConsumptionLimitResponse>* PrepareAsyncPendingConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::PendingConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* AsyncApproveOrDenyConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* PrepareAsyncApproveOrDenyConsumptionLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* AsyncFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* PrepareAsyncFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* AsyncSetFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* PrepareAsyncSetFailsafeConsumptionActivePowerLimitRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>* AsyncFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::FailsafeDurationMinimumResponse>* PrepareAsyncFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>* AsyncSetFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetFailsafeDurationMinimumResponse>* PrepareAsyncSetFailsafeDurationMinimumRaw(::grpc::ClientContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>* AsyncStartHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::StartHeartbeatResponse>* PrepareAsyncStartHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StartHeartbeatRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>* AsyncStopHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::StopHeartbeatResponse>* PrepareAsyncStopHeartbeatRaw(::grpc::ClientContext* context, const ::cs_lpc::StopHeartbeatRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>* AsyncIsHeartbeatWithinDurationRaw(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::IsHeartbeatWithinDurationResponse>* PrepareAsyncIsHeartbeatWithinDurationRaw(::grpc::ClientContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>* AsyncConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::ConsumptionNominalMaxResponse>* PrepareAsyncConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>* AsyncSetConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::cs_lpc::SetConsumptionNominalMaxResponse>* PrepareAsyncSetConsumptionNominalMaxRaw(::grpc::ClientContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_ConsumptionLimit_; + const ::grpc::internal::RpcMethod rpcmethod_SetConsumptionLimit_; + const ::grpc::internal::RpcMethod rpcmethod_PendingConsumptionLimit_; + const ::grpc::internal::RpcMethod rpcmethod_ApproveOrDenyConsumptionLimit_; + const ::grpc::internal::RpcMethod rpcmethod_FailsafeConsumptionActivePowerLimit_; + const ::grpc::internal::RpcMethod rpcmethod_SetFailsafeConsumptionActivePowerLimit_; + const ::grpc::internal::RpcMethod rpcmethod_FailsafeDurationMinimum_; + const ::grpc::internal::RpcMethod rpcmethod_SetFailsafeDurationMinimum_; + const ::grpc::internal::RpcMethod rpcmethod_StartHeartbeat_; + const ::grpc::internal::RpcMethod rpcmethod_StopHeartbeat_; + const ::grpc::internal::RpcMethod rpcmethod_IsHeartbeatWithinDuration_; + const ::grpc::internal::RpcMethod rpcmethod_ConsumptionNominalMax_; + const ::grpc::internal::RpcMethod rpcmethod_SetConsumptionNominalMax_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + virtual ::grpc::Status ConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response); + virtual ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response); + virtual ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response); + virtual ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response); + virtual ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response); + virtual ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response); + virtual ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response); + virtual ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response); + virtual ::grpc::Status StartHeartbeat(::grpc::ServerContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response); + virtual ::grpc::Status StopHeartbeat(::grpc::ServerContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response); + virtual ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response); + virtual ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response); + virtual ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response); + }; + template + class WithAsyncMethod_ConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ConsumptionLimit() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_ConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestConsumptionLimit(::grpc::ServerContext* context, ::cs_lpc::ConsumptionLimitRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::ConsumptionLimitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SetConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetConsumptionLimit() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_SetConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetConsumptionLimit(::grpc::ServerContext* context, ::cs_lpc::SetConsumptionLimitRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::SetConsumptionLimitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_PendingConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_PendingConsumptionLimit() { + ::grpc::Service::MarkMethodAsync(2); + } + ~WithAsyncMethod_PendingConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestPendingConsumptionLimit(::grpc::ServerContext* context, ::cs_lpc::PendingConsumptionLimitRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::PendingConsumptionLimitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_ApproveOrDenyConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ApproveOrDenyConsumptionLimit() { + ::grpc::Service::MarkMethodAsync(3); + } + ~WithAsyncMethod_ApproveOrDenyConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestApproveOrDenyConsumptionLimit(::grpc::ServerContext* context, ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_FailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_FailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodAsync(4); + } + ~WithAsyncMethod_FailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SetFailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetFailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodAsync(5); + } + ~WithAsyncMethod_SetFailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_FailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_FailsafeDurationMinimum() { + ::grpc::Service::MarkMethodAsync(6); + } + ~WithAsyncMethod_FailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailsafeDurationMinimum(::grpc::ServerContext* context, ::cs_lpc::FailsafeDurationMinimumRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::FailsafeDurationMinimumResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SetFailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetFailsafeDurationMinimum() { + ::grpc::Service::MarkMethodAsync(7); + } + ~WithAsyncMethod_SetFailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetFailsafeDurationMinimum(::grpc::ServerContext* context, ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::SetFailsafeDurationMinimumResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StartHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StartHeartbeat() { + ::grpc::Service::MarkMethodAsync(8); + } + ~WithAsyncMethod_StartHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartHeartbeat(::grpc::ServerContext* context, ::cs_lpc::StartHeartbeatRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::StartHeartbeatResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StopHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StopHeartbeat() { + ::grpc::Service::MarkMethodAsync(9); + } + ~WithAsyncMethod_StopHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStopHeartbeat(::grpc::ServerContext* context, ::cs_lpc::StopHeartbeatRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::StopHeartbeatResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_IsHeartbeatWithinDuration : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_IsHeartbeatWithinDuration() { + ::grpc::Service::MarkMethodAsync(10); + } + ~WithAsyncMethod_IsHeartbeatWithinDuration() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestIsHeartbeatWithinDuration(::grpc::ServerContext* context, ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::IsHeartbeatWithinDurationResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_ConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ConsumptionNominalMax() { + ::grpc::Service::MarkMethodAsync(11); + } + ~WithAsyncMethod_ConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestConsumptionNominalMax(::grpc::ServerContext* context, ::cs_lpc::ConsumptionNominalMaxRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::ConsumptionNominalMaxResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SetConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetConsumptionNominalMax() { + ::grpc::Service::MarkMethodAsync(12); + } + ~WithAsyncMethod_SetConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetConsumptionNominalMax(::grpc::ServerContext* context, ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::grpc::ServerAsyncResponseWriter< ::cs_lpc::SetConsumptionNominalMaxResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_ConsumptionLimit > > > > > > > > > > > > AsyncService; + template + class WithCallbackMethod_ConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_ConsumptionLimit() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::ConsumptionLimitRequest* request, ::cs_lpc::ConsumptionLimitResponse* response) { return this->ConsumptionLimit(context, request, response); }));} + void SetMessageAllocatorFor_ConsumptionLimit( + ::grpc::MessageAllocator< ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_ConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* ConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SetConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetConsumptionLimit() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::SetConsumptionLimitRequest* request, ::cs_lpc::SetConsumptionLimitResponse* response) { return this->SetConsumptionLimit(context, request, response); }));} + void SetMessageAllocatorFor_SetConsumptionLimit( + ::grpc::MessageAllocator< ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_PendingConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_PendingConsumptionLimit() { + ::grpc::Service::MarkMethodCallback(2, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::PendingConsumptionLimitRequest* request, ::cs_lpc::PendingConsumptionLimitResponse* response) { return this->PendingConsumptionLimit(context, request, response); }));} + void SetMessageAllocatorFor_PendingConsumptionLimit( + ::grpc::MessageAllocator< ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_PendingConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* PendingConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_ApproveOrDenyConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_ApproveOrDenyConsumptionLimit() { + ::grpc::Service::MarkMethodCallback(3, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* request, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* response) { return this->ApproveOrDenyConsumptionLimit(context, request, response); }));} + void SetMessageAllocatorFor_ApproveOrDenyConsumptionLimit( + ::grpc::MessageAllocator< ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_ApproveOrDenyConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* ApproveOrDenyConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_FailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_FailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodCallback(4, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* response) { return this->FailsafeConsumptionActivePowerLimit(context, request, response); }));} + void SetMessageAllocatorFor_FailsafeConsumptionActivePowerLimit( + ::grpc::MessageAllocator< ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_FailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* FailsafeConsumptionActivePowerLimit( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SetFailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetFailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodCallback(5, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* request, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* response) { return this->SetFailsafeConsumptionActivePowerLimit(context, request, response); }));} + void SetMessageAllocatorFor_SetFailsafeConsumptionActivePowerLimit( + ::grpc::MessageAllocator< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetFailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetFailsafeConsumptionActivePowerLimit( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_FailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_FailsafeDurationMinimum() { + ::grpc::Service::MarkMethodCallback(6, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::FailsafeDurationMinimumRequest* request, ::cs_lpc::FailsafeDurationMinimumResponse* response) { return this->FailsafeDurationMinimum(context, request, response); }));} + void SetMessageAllocatorFor_FailsafeDurationMinimum( + ::grpc::MessageAllocator< ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_FailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* FailsafeDurationMinimum( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SetFailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetFailsafeDurationMinimum() { + ::grpc::Service::MarkMethodCallback(7, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::SetFailsafeDurationMinimumRequest* request, ::cs_lpc::SetFailsafeDurationMinimumResponse* response) { return this->SetFailsafeDurationMinimum(context, request, response); }));} + void SetMessageAllocatorFor_SetFailsafeDurationMinimum( + ::grpc::MessageAllocator< ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetFailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetFailsafeDurationMinimum( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_StartHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StartHeartbeat() { + ::grpc::Service::MarkMethodCallback(8, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::StartHeartbeatRequest* request, ::cs_lpc::StartHeartbeatResponse* response) { return this->StartHeartbeat(context, request, response); }));} + void SetMessageAllocatorFor_StartHeartbeat( + ::grpc::MessageAllocator< ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(8); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StartHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StartHeartbeat( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_StopHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StopHeartbeat() { + ::grpc::Service::MarkMethodCallback(9, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::StopHeartbeatRequest* request, ::cs_lpc::StopHeartbeatResponse* response) { return this->StopHeartbeat(context, request, response); }));} + void SetMessageAllocatorFor_StopHeartbeat( + ::grpc::MessageAllocator< ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StopHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StopHeartbeat( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_IsHeartbeatWithinDuration : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_IsHeartbeatWithinDuration() { + ::grpc::Service::MarkMethodCallback(10, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::IsHeartbeatWithinDurationRequest* request, ::cs_lpc::IsHeartbeatWithinDurationResponse* response) { return this->IsHeartbeatWithinDuration(context, request, response); }));} + void SetMessageAllocatorFor_IsHeartbeatWithinDuration( + ::grpc::MessageAllocator< ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(10); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_IsHeartbeatWithinDuration() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* IsHeartbeatWithinDuration( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_ConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_ConsumptionNominalMax() { + ::grpc::Service::MarkMethodCallback(11, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::ConsumptionNominalMaxRequest* request, ::cs_lpc::ConsumptionNominalMaxResponse* response) { return this->ConsumptionNominalMax(context, request, response); }));} + void SetMessageAllocatorFor_ConsumptionNominalMax( + ::grpc::MessageAllocator< ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(11); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_ConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* ConsumptionNominalMax( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SetConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetConsumptionNominalMax() { + ::grpc::Service::MarkMethodCallback(12, + new ::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::cs_lpc::SetConsumptionNominalMaxRequest* request, ::cs_lpc::SetConsumptionNominalMaxResponse* response) { return this->SetConsumptionNominalMax(context, request, response); }));} + void SetMessageAllocatorFor_SetConsumptionNominalMax( + ::grpc::MessageAllocator< ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(12); + static_cast<::grpc::internal::CallbackUnaryHandler< ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetConsumptionNominalMax( + ::grpc::CallbackServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) { return nullptr; } + }; + typedef WithCallbackMethod_ConsumptionLimit > > > > > > > > > > > > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_ConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ConsumptionLimit() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_ConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SetConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetConsumptionLimit() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_SetConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_PendingConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_PendingConsumptionLimit() { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_PendingConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_ApproveOrDenyConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ApproveOrDenyConsumptionLimit() { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_ApproveOrDenyConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_FailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_FailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodGeneric(4); + } + ~WithGenericMethod_FailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SetFailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetFailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodGeneric(5); + } + ~WithGenericMethod_SetFailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_FailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_FailsafeDurationMinimum() { + ::grpc::Service::MarkMethodGeneric(6); + } + ~WithGenericMethod_FailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SetFailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetFailsafeDurationMinimum() { + ::grpc::Service::MarkMethodGeneric(7); + } + ~WithGenericMethod_SetFailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_StartHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StartHeartbeat() { + ::grpc::Service::MarkMethodGeneric(8); + } + ~WithGenericMethod_StartHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_StopHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StopHeartbeat() { + ::grpc::Service::MarkMethodGeneric(9); + } + ~WithGenericMethod_StopHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_IsHeartbeatWithinDuration : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_IsHeartbeatWithinDuration() { + ::grpc::Service::MarkMethodGeneric(10); + } + ~WithGenericMethod_IsHeartbeatWithinDuration() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_ConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ConsumptionNominalMax() { + ::grpc::Service::MarkMethodGeneric(11); + } + ~WithGenericMethod_ConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SetConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetConsumptionNominalMax() { + ::grpc::Service::MarkMethodGeneric(12); + } + ~WithGenericMethod_SetConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_ConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ConsumptionLimit() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_ConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestConsumptionLimit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SetConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetConsumptionLimit() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_SetConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetConsumptionLimit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_PendingConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_PendingConsumptionLimit() { + ::grpc::Service::MarkMethodRaw(2); + } + ~WithRawMethod_PendingConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestPendingConsumptionLimit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_ApproveOrDenyConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ApproveOrDenyConsumptionLimit() { + ::grpc::Service::MarkMethodRaw(3); + } + ~WithRawMethod_ApproveOrDenyConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestApproveOrDenyConsumptionLimit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_FailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_FailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodRaw(4); + } + ~WithRawMethod_FailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SetFailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetFailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodRaw(5); + } + ~WithRawMethod_SetFailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_FailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_FailsafeDurationMinimum() { + ::grpc::Service::MarkMethodRaw(6); + } + ~WithRawMethod_FailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailsafeDurationMinimum(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SetFailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetFailsafeDurationMinimum() { + ::grpc::Service::MarkMethodRaw(7); + } + ~WithRawMethod_SetFailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetFailsafeDurationMinimum(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StartHeartbeat() { + ::grpc::Service::MarkMethodRaw(8); + } + ~WithRawMethod_StartHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartHeartbeat(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StopHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StopHeartbeat() { + ::grpc::Service::MarkMethodRaw(9); + } + ~WithRawMethod_StopHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStopHeartbeat(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_IsHeartbeatWithinDuration : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_IsHeartbeatWithinDuration() { + ::grpc::Service::MarkMethodRaw(10); + } + ~WithRawMethod_IsHeartbeatWithinDuration() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestIsHeartbeatWithinDuration(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_ConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ConsumptionNominalMax() { + ::grpc::Service::MarkMethodRaw(11); + } + ~WithRawMethod_ConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestConsumptionNominalMax(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SetConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetConsumptionNominalMax() { + ::grpc::Service::MarkMethodRaw(12); + } + ~WithRawMethod_SetConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetConsumptionNominalMax(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_ConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_ConsumptionLimit() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ConsumptionLimit(context, request, response); })); + } + ~WithRawCallbackMethod_ConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* ConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SetConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetConsumptionLimit() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetConsumptionLimit(context, request, response); })); + } + ~WithRawCallbackMethod_SetConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_PendingConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_PendingConsumptionLimit() { + ::grpc::Service::MarkMethodRawCallback(2, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PendingConsumptionLimit(context, request, response); })); + } + ~WithRawCallbackMethod_PendingConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* PendingConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_ApproveOrDenyConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_ApproveOrDenyConsumptionLimit() { + ::grpc::Service::MarkMethodRawCallback(3, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ApproveOrDenyConsumptionLimit(context, request, response); })); + } + ~WithRawCallbackMethod_ApproveOrDenyConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* ApproveOrDenyConsumptionLimit( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_FailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_FailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodRawCallback(4, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->FailsafeConsumptionActivePowerLimit(context, request, response); })); + } + ~WithRawCallbackMethod_FailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* FailsafeConsumptionActivePowerLimit( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SetFailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetFailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodRawCallback(5, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetFailsafeConsumptionActivePowerLimit(context, request, response); })); + } + ~WithRawCallbackMethod_SetFailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetFailsafeConsumptionActivePowerLimit( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_FailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_FailsafeDurationMinimum() { + ::grpc::Service::MarkMethodRawCallback(6, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->FailsafeDurationMinimum(context, request, response); })); + } + ~WithRawCallbackMethod_FailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* FailsafeDurationMinimum( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SetFailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetFailsafeDurationMinimum() { + ::grpc::Service::MarkMethodRawCallback(7, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetFailsafeDurationMinimum(context, request, response); })); + } + ~WithRawCallbackMethod_SetFailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetFailsafeDurationMinimum( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_StartHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StartHeartbeat() { + ::grpc::Service::MarkMethodRawCallback(8, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->StartHeartbeat(context, request, response); })); + } + ~WithRawCallbackMethod_StartHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StartHeartbeat( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_StopHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StopHeartbeat() { + ::grpc::Service::MarkMethodRawCallback(9, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->StopHeartbeat(context, request, response); })); + } + ~WithRawCallbackMethod_StopHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StopHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* StopHeartbeat( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_IsHeartbeatWithinDuration : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_IsHeartbeatWithinDuration() { + ::grpc::Service::MarkMethodRawCallback(10, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->IsHeartbeatWithinDuration(context, request, response); })); + } + ~WithRawCallbackMethod_IsHeartbeatWithinDuration() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* IsHeartbeatWithinDuration( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_ConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_ConsumptionNominalMax() { + ::grpc::Service::MarkMethodRawCallback(11, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ConsumptionNominalMax(context, request, response); })); + } + ~WithRawCallbackMethod_ConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* ConsumptionNominalMax( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SetConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetConsumptionNominalMax() { + ::grpc::Service::MarkMethodRawCallback(12, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetConsumptionNominalMax(context, request, response); })); + } + ~WithRawCallbackMethod_SetConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetConsumptionNominalMax( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_ConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ConsumptionLimit() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::ConsumptionLimitRequest, ::cs_lpc::ConsumptionLimitResponse>* streamer) { + return this->StreamedConsumptionLimit(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_ConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionLimitRequest* /*request*/, ::cs_lpc::ConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedConsumptionLimit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::ConsumptionLimitRequest,::cs_lpc::ConsumptionLimitResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SetConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetConsumptionLimit() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::SetConsumptionLimitRequest, ::cs_lpc::SetConsumptionLimitResponse>* streamer) { + return this->StreamedSetConsumptionLimit(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionLimitRequest* /*request*/, ::cs_lpc::SetConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetConsumptionLimit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::SetConsumptionLimitRequest,::cs_lpc::SetConsumptionLimitResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_PendingConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_PendingConsumptionLimit() { + ::grpc::Service::MarkMethodStreamed(2, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::PendingConsumptionLimitRequest, ::cs_lpc::PendingConsumptionLimitResponse>* streamer) { + return this->StreamedPendingConsumptionLimit(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_PendingConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status PendingConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::PendingConsumptionLimitRequest* /*request*/, ::cs_lpc::PendingConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedPendingConsumptionLimit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::PendingConsumptionLimitRequest,::cs_lpc::PendingConsumptionLimitResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_ApproveOrDenyConsumptionLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ApproveOrDenyConsumptionLimit() { + ::grpc::Service::MarkMethodStreamed(3, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::ApproveOrDenyConsumptionLimitRequest, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* streamer) { + return this->StreamedApproveOrDenyConsumptionLimit(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_ApproveOrDenyConsumptionLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ApproveOrDenyConsumptionLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::ApproveOrDenyConsumptionLimitRequest* /*request*/, ::cs_lpc::ApproveOrDenyConsumptionLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedApproveOrDenyConsumptionLimit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::ApproveOrDenyConsumptionLimitRequest,::cs_lpc::ApproveOrDenyConsumptionLimitResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_FailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_FailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodStreamed(4, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* streamer) { + return this->StreamedFailsafeConsumptionActivePowerLimit(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_FailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status FailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::FailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::FailsafeConsumptionActivePowerLimitRequest,::cs_lpc::FailsafeConsumptionActivePowerLimitResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SetFailsafeConsumptionActivePowerLimit : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetFailsafeConsumptionActivePowerLimit() { + ::grpc::Service::MarkMethodStreamed(5, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* streamer) { + return this->StreamedSetFailsafeConsumptionActivePowerLimit(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetFailsafeConsumptionActivePowerLimit() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest* /*request*/, ::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetFailsafeConsumptionActivePowerLimit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::SetFailsafeConsumptionActivePowerLimitRequest,::cs_lpc::SetFailsafeConsumptionActivePowerLimitResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_FailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_FailsafeDurationMinimum() { + ::grpc::Service::MarkMethodStreamed(6, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::FailsafeDurationMinimumRequest, ::cs_lpc::FailsafeDurationMinimumResponse>* streamer) { + return this->StreamedFailsafeDurationMinimum(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_FailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status FailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::FailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::FailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedFailsafeDurationMinimum(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::FailsafeDurationMinimumRequest,::cs_lpc::FailsafeDurationMinimumResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SetFailsafeDurationMinimum : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetFailsafeDurationMinimum() { + ::grpc::Service::MarkMethodStreamed(7, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::SetFailsafeDurationMinimumRequest, ::cs_lpc::SetFailsafeDurationMinimumResponse>* streamer) { + return this->StreamedSetFailsafeDurationMinimum(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetFailsafeDurationMinimum() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetFailsafeDurationMinimum(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetFailsafeDurationMinimumRequest* /*request*/, ::cs_lpc::SetFailsafeDurationMinimumResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetFailsafeDurationMinimum(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::SetFailsafeDurationMinimumRequest,::cs_lpc::SetFailsafeDurationMinimumResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_StartHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_StartHeartbeat() { + ::grpc::Service::MarkMethodStreamed(8, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::StartHeartbeatRequest, ::cs_lpc::StartHeartbeatResponse>* streamer) { + return this->StreamedStartHeartbeat(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_StartHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StartHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StartHeartbeatRequest* /*request*/, ::cs_lpc::StartHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStartHeartbeat(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::StartHeartbeatRequest,::cs_lpc::StartHeartbeatResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_StopHeartbeat : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_StopHeartbeat() { + ::grpc::Service::MarkMethodStreamed(9, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::StopHeartbeatRequest, ::cs_lpc::StopHeartbeatResponse>* streamer) { + return this->StreamedStopHeartbeat(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_StopHeartbeat() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StopHeartbeat(::grpc::ServerContext* /*context*/, const ::cs_lpc::StopHeartbeatRequest* /*request*/, ::cs_lpc::StopHeartbeatResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStopHeartbeat(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::StopHeartbeatRequest,::cs_lpc::StopHeartbeatResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_IsHeartbeatWithinDuration : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_IsHeartbeatWithinDuration() { + ::grpc::Service::MarkMethodStreamed(10, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::IsHeartbeatWithinDurationRequest, ::cs_lpc::IsHeartbeatWithinDurationResponse>* streamer) { + return this->StreamedIsHeartbeatWithinDuration(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_IsHeartbeatWithinDuration() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status IsHeartbeatWithinDuration(::grpc::ServerContext* /*context*/, const ::cs_lpc::IsHeartbeatWithinDurationRequest* /*request*/, ::cs_lpc::IsHeartbeatWithinDurationResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedIsHeartbeatWithinDuration(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::IsHeartbeatWithinDurationRequest,::cs_lpc::IsHeartbeatWithinDurationResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_ConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ConsumptionNominalMax() { + ::grpc::Service::MarkMethodStreamed(11, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::ConsumptionNominalMaxRequest, ::cs_lpc::ConsumptionNominalMaxResponse>* streamer) { + return this->StreamedConsumptionNominalMax(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_ConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::ConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::ConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedConsumptionNominalMax(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::ConsumptionNominalMaxRequest,::cs_lpc::ConsumptionNominalMaxResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SetConsumptionNominalMax : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetConsumptionNominalMax() { + ::grpc::Service::MarkMethodStreamed(12, + new ::grpc::internal::StreamedUnaryHandler< + ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::cs_lpc::SetConsumptionNominalMaxRequest, ::cs_lpc::SetConsumptionNominalMaxResponse>* streamer) { + return this->StreamedSetConsumptionNominalMax(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetConsumptionNominalMax() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetConsumptionNominalMax(::grpc::ServerContext* /*context*/, const ::cs_lpc::SetConsumptionNominalMaxRequest* /*request*/, ::cs_lpc::SetConsumptionNominalMaxResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetConsumptionNominalMax(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::cs_lpc::SetConsumptionNominalMaxRequest,::cs_lpc::SetConsumptionNominalMaxResponse>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_ConsumptionLimit > > > > > > > > > > > > StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_ConsumptionLimit > > > > > > > > > > > > StreamedService; +}; + +} // namespace cs_lpc + + +#include +#endif // GRPC_usecases_2fcs_2flpc_2fservice_2eproto__INCLUDED diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.cc b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.cc new file mode 100644 index 0000000000..398b6b7a2c --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.cc @@ -0,0 +1,113 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: usecases/cs/lpc/service.proto +// Protobuf C++ Version: 5.29.0 + +#include "usecases/cs/lpc/service.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace cs_lpc { +} // namespace cs_lpc +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_usecases_2fcs_2flpc_2fservice_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_usecases_2fcs_2flpc_2fservice_2eproto = nullptr; +const ::uint32_t TableStruct_usecases_2fcs_2flpc_2fservice_2eproto::offsets[1] = {}; +static constexpr ::_pbi::MigrationSchema* schemas = nullptr; +static constexpr ::_pb::Message* const* file_default_instances = nullptr; +const char descriptor_table_protodef_usecases_2fcs_2flpc_2fservice_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\035usecases/cs/lpc/service.proto\022\006cs_lpc\032" + "\036usecases/cs/lpc/messages.proto2\313\013\n\034Cont" + "rollableSystemLPCControl\022W\n\020ConsumptionL" + "imit\022\037.cs_lpc.ConsumptionLimitRequest\032 ." + "cs_lpc.ConsumptionLimitResponse\"\000\022`\n\023Set" + "ConsumptionLimit\022\".cs_lpc.SetConsumption" + "LimitRequest\032#.cs_lpc.SetConsumptionLimi" + "tResponse\"\000\022l\n\027PendingConsumptionLimit\022&" + ".cs_lpc.PendingConsumptionLimitRequest\032\'" + ".cs_lpc.PendingConsumptionLimitResponse\"" + "\000\022~\n\035ApproveOrDenyConsumptionLimit\022,.cs_" + "lpc.ApproveOrDenyConsumptionLimitRequest" + "\032-.cs_lpc.ApproveOrDenyConsumptionLimitR" + "esponse\"\000\022\220\001\n#FailsafeConsumptionActiveP" + "owerLimit\0222.cs_lpc.FailsafeConsumptionAc" + "tivePowerLimitRequest\0323.cs_lpc.FailsafeC" + "onsumptionActivePowerLimitResponse\"\000\022\231\001\n" + "&SetFailsafeConsumptionActivePowerLimit\022" + "5.cs_lpc.SetFailsafeConsumptionActivePow" + "erLimitRequest\0326.cs_lpc.SetFailsafeConsu" + "mptionActivePowerLimitResponse\"\000\022l\n\027Fail" + "safeDurationMinimum\022&.cs_lpc.FailsafeDur" + "ationMinimumRequest\032\'.cs_lpc.FailsafeDur" + "ationMinimumResponse\"\000\022u\n\032SetFailsafeDur" + "ationMinimum\022).cs_lpc.SetFailsafeDuratio" + "nMinimumRequest\032*.cs_lpc.SetFailsafeDura" + "tionMinimumResponse\"\000\022Q\n\016StartHeartbeat\022" + "\035.cs_lpc.StartHeartbeatRequest\032\036.cs_lpc." + "StartHeartbeatResponse\"\000\022N\n\rStopHeartbea" + "t\022\034.cs_lpc.StopHeartbeatRequest\032\035.cs_lpc" + ".StopHeartbeatResponse\"\000\022r\n\031IsHeartbeatW" + "ithinDuration\022(.cs_lpc.IsHeartbeatWithin" + "DurationRequest\032).cs_lpc.IsHeartbeatWith" + "inDurationResponse\"\000\022f\n\025ConsumptionNomin" + "alMax\022$.cs_lpc.ConsumptionNominalMaxRequ" + "est\032%.cs_lpc.ConsumptionNominalMaxRespon" + "se\"\000\022o\n\030SetConsumptionNominalMax\022\'.cs_lp" + "c.SetConsumptionNominalMaxRequest\032(.cs_l" + "pc.SetConsumptionNominalMaxResponse\"\000B=Z" + ";github.com/enbility/eebus-grpc/rpc_serv" + "ices/usecases/cs/lpcb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto_deps[1] = + { + &::descriptor_table_usecases_2fcs_2flpc_2fmessages_2eproto, +}; +static ::absl::once_flag descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto_once; +PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto = { + false, + false, + 1628, + descriptor_table_protodef_usecases_2fcs_2flpc_2fservice_2eproto, + "usecases/cs/lpc/service.proto", + &descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto_once, + descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto_deps, + 1, + 0, + schemas, + file_default_instances, + TableStruct_usecases_2fcs_2flpc_2fservice_2eproto::offsets, + file_level_enum_descriptors_usecases_2fcs_2flpc_2fservice_2eproto, + file_level_service_descriptors_usecases_2fcs_2flpc_2fservice_2eproto, +}; +namespace cs_lpc { +// @@protoc_insertion_point(namespace_scope) +} // namespace cs_lpc +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type + _static_init2_ PROTOBUF_UNUSED = + (::_pbi::AddDescriptors(&descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto), + ::std::false_type{}); +#include "google/protobuf/port_undef.inc" diff --git a/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.h b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.h new file mode 100644 index 0000000000..16c2c4c46d --- /dev/null +++ b/modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.h @@ -0,0 +1,87 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: usecases/cs/lpc/service.proto +// Protobuf C++ Version: 5.29.0 + +#ifndef usecases_2fcs_2flpc_2fservice_2eproto_2epb_2eh +#define usecases_2fcs_2flpc_2fservice_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029000 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "usecases/cs/lpc/messages.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_usecases_2fcs_2flpc_2fservice_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_usecases_2fcs_2flpc_2fservice_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_usecases_2fcs_2flpc_2fservice_2eproto; +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace cs_lpc { + +// =================================================================== + + + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace cs_lpc + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // usecases_2fcs_2flpc_2fservice_2eproto_2epb_2eh diff --git a/modules/EnergyManagement/EEBUS/helper.cpp b/modules/EnergyManagement/EEBUS/helper.cpp new file mode 100644 index 0000000000..2b533ba945 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/helper.cpp @@ -0,0 +1,57 @@ +#include "helper.hpp" + +namespace module { + +bool compare_use_case(const control_service::UseCase& uc1, const control_service::UseCase& uc2) { + if (uc1.actor() != uc2.actor()) { + return false; + } + if (uc1.name() != uc2.name()) { + return false; + } + return true; +} + +types::energy::ScheduleReqEntry create_active_schedule_req_entry(std::chrono::time_point timestamp, + double total_power_W) { + types::energy::ScheduleReqEntry schedule_req_entry; + types::energy::LimitsReq limits_req; + schedule_req_entry.timestamp = Everest::Date::to_rfc3339(timestamp); + types::energy::NumberWithSource total_power; + total_power.value = total_power_W; + total_power.source = "EEBUS LPC"; + limits_req.total_power_W = total_power; + schedule_req_entry.limits_to_leaves = limits_req; + schedule_req_entry.limits_to_root = limits_req; + return schedule_req_entry; +} + +types::energy::ScheduleReqEntry create_inactive_schedule_req_entry(std::chrono::time_point timestamp) { + types::energy::ScheduleReqEntry schedule_req_entry; + schedule_req_entry.timestamp = Everest::Date::to_rfc3339(timestamp); + schedule_req_entry.limits_to_leaves = types::energy::LimitsReq(); + schedule_req_entry.limits_to_root = types::energy::LimitsReq(); + return schedule_req_entry; +} + +types::energy::ExternalLimits translate_to_external_limits(const common_types::LoadLimit& load_limit) { + types::energy::ExternalLimits limits; + std::vector schedule_import; + if (load_limit.is_active()) { + schedule_import.push_back(create_active_schedule_req_entry( + date::utc_clock::from_sys(std::chrono::system_clock::now()), load_limit.value())); + if (load_limit.duration_nanoseconds() > 0) { + std::chrono::time_point timestamp; + timestamp = date::utc_clock::from_sys(std::chrono::system_clock::now()); + timestamp += std::chrono::nanoseconds(load_limit.duration_nanoseconds()); + schedule_import.push_back(create_inactive_schedule_req_entry(timestamp)); + } + } else { + schedule_import.push_back( + create_inactive_schedule_req_entry(date::utc_clock::from_sys(std::chrono::system_clock::now()))); + } + limits.schedule_import = schedule_import; + return limits; +} + +} // namespace module diff --git a/modules/EnergyManagement/EEBUS/include/ConfigValidator.hpp b/modules/EnergyManagement/EEBUS/include/ConfigValidator.hpp new file mode 100644 index 0000000000..1f24e505ca --- /dev/null +++ b/modules/EnergyManagement/EEBUS/include/ConfigValidator.hpp @@ -0,0 +1,61 @@ + +#ifndef EVEREST_CORE_MODULES_EEBUS_INCLUDE_CONFIGVALIDATOR_HPP +#define EVEREST_CORE_MODULES_EEBUS_INCLUDE_CONFIGVALIDATOR_HPP + +#include +#include + +namespace module { + +class Conf; + +class ConfigValidator { +public: + ConfigValidator(const Conf& config, std::filesystem::path etc_prefix, std::filesystem::path libexec_prefix); + + bool validate(); + + std::filesystem::path get_certificate_path() const; + std::filesystem::path get_private_key_path() const; + std::filesystem::path get_eebus_grpc_api_binary_path() const; + int get_eebus_service_port() const; + int get_grpc_port() const; + std::string get_vendor_code() const; + std::string get_device_brand() const; + std::string get_device_model() const; + std::string get_serial_number() const; + int get_failsafe_control_limit() const; + int get_max_nominal_power() const; + std::string get_eebus_ems_ski() const; + +private: + bool validate_eebus_service_port() const; + bool validate_grpc_port() const; + bool validate_eebus_ems_ski() const; + bool validate_certificate_path(); + bool validate_private_key_path(); + bool validate_eebus_grpc_api_binary_path(); + bool validate_manage_eebus_grpc_api_binary() const; + bool validate_vendor_code() const; + bool validate_device_brand() const; + bool validate_device_model() const; + bool validate_serial_number() const; + bool validate_failsafe_control_limit() const; + bool validate_max_nominal_power() const; + + const Conf& config; + + std::filesystem::path etc_prefix; + std::filesystem::path libexec_prefix; + + std::filesystem::path certificate_path; + std::filesystem::path private_key_path; + std::filesystem::path eebus_grpc_api_binary_path; + int eebus_service_port; + int grpc_port; + bool manage_eebus_grpc_api_binary; +}; + +} // namespace module + +#endif // EVEREST_CORE_MODULES_EEBUS_INCLUDE_CONFIGVALIDATOR_HPP diff --git a/modules/EnergyManagement/EEBUS/include/EebusCallbacks.hpp b/modules/EnergyManagement/EEBUS/include/EebusCallbacks.hpp new file mode 100644 index 0000000000..eaed5a4044 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/include/EebusCallbacks.hpp @@ -0,0 +1,15 @@ +#ifndef EVEREST_CORE_MODULES_EEBUS_INCLUDE_EEBUS_CALLBACKS_HPP +#define EVEREST_CORE_MODULES_EEBUS_INCLUDE_EEBUS_CALLBACKS_HPP + +#include + +namespace module::eebus { + +struct EEBusCallbacks { + [[nodiscard]] bool all_callbacks_valid() const; + std::function update_limits_callback; +}; + +} // namespace module::eebus + +#endif // EVEREST_CORE_MODULES_EEBUS_INCLUDE_EEBUS_CALLBACKS_HPP diff --git a/modules/EnergyManagement/EEBUS/include/EebusConnectionHandler.hpp b/modules/EnergyManagement/EEBUS/include/EebusConnectionHandler.hpp new file mode 100644 index 0000000000..475c0482b5 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/include/EebusConnectionHandler.hpp @@ -0,0 +1,47 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#ifndef MODULES_ENERGYMANAGEMENT_EEBUS_INCLUDE_EEBUSCONNECTIONHANDLER_HPP +#define MODULES_ENERGYMANAGEMENT_EEBUS_INCLUDE_EEBUSCONNECTIONHANDLER_HPP + +#include + +#include +#include +#include + +#include +#include + +namespace module { + +class EebusConnectionHandler { +public: + explicit EebusConnectionHandler(std::shared_ptr config); + ~EebusConnectionHandler(); + EebusConnectionHandler(const EebusConnectionHandler&) = delete; + EebusConnectionHandler& operator=(const EebusConnectionHandler&) = delete; + EebusConnectionHandler(EebusConnectionHandler&&) = default; + EebusConnectionHandler& operator=(EebusConnectionHandler&&) = default; + + bool initialize_connection(); + bool start_service(); + bool add_lpc_use_case(const eebus::EEBusCallbacks& callbacks); + void subscribe_to_events(); + void stop(); + +private: + static bool wait_for_channel_ready(const std::shared_ptr& channel, + std::chrono::milliseconds timeout); + + std::shared_ptr config; + std::unique_ptr lpc_handler; + + std::unique_ptr event_reader; + + std::shared_ptr control_service_channel; + std::shared_ptr control_service_stub; +}; + +} // namespace module + +#endif // MODULES_ENERGYMANAGEMENT_EEBUS_INCLUDE_EEBUSCONNECTIONHANDLER_HPP diff --git a/modules/EnergyManagement/EEBUS/include/LpcUseCaseHandler.hpp b/modules/EnergyManagement/EEBUS/include/LpcUseCaseHandler.hpp new file mode 100644 index 0000000000..ee4a4d6165 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/include/LpcUseCaseHandler.hpp @@ -0,0 +1,86 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#ifndef MODULES_ENERGYMANAGEMENT_EEBUS_INCLUDE_LPCUSECASEHANDLER_HPP +#define MODULES_ENERGYMANAGEMENT_EEBUS_INCLUDE_LPCUSECASEHANDLER_HPP + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +namespace module { + +class LpcUseCaseHandler { +public: + enum class State : uint8_t { + Init, + UnlimitedControlled, + Limited, + Failsafe, + UnlimitedAutonomous + }; + + LpcUseCaseHandler(std::shared_ptr config, eebus::EEBusCallbacks callbacks); + ~LpcUseCaseHandler(); + LpcUseCaseHandler(const LpcUseCaseHandler&) = delete; + LpcUseCaseHandler& operator=(const LpcUseCaseHandler&) = delete; + LpcUseCaseHandler(LpcUseCaseHandler&&) = delete; + LpcUseCaseHandler& operator=(LpcUseCaseHandler&&) = delete; + + void start(); + void stop(); + + void set_stub(std::shared_ptr stub); + void handle_event(const control_service::UseCaseEvent& event); + static control_service::UseCase get_use_case_info(); + void configure_use_case(); + +private: + void run(); + void set_state(State new_state); + static std::string state_to_string(State state); + + void approve_pending_writes(); + void update_limit_from_event(); + void apply_limit_for_current_state(); + void start_heartbeat(); + + std::shared_ptr config; + eebus::EEBusCallbacks callbacks; + std::shared_ptr stub; + + std::thread worker_thread; + std::atomic running{false}; + std::atomic state; + std::atomic state_changed{false}; + std::condition_variable cv; + + std::queue event_queue; + std::mutex queue_mutex; + + std::atomic limit_value_changed{false}; + std::optional current_limit; + std::mutex limit_mutex; + + std::chrono::time_point last_heartbeat_timestamp; + std::mutex heartbeat_mutex; + + std::chrono::seconds heartbeat_timeout; + std::chrono::time_point init_timestamp; + std::chrono::time_point failsafe_entry_timestamp; + std::chrono::time_point last_limit_received_timestamp; + std::chrono::nanoseconds failsafe_duration_timeout; + double failsafe_control_limit; +}; + +} // namespace module + +#endif // MODULES_ENERGYMANAGEMENT_EEBUS_INCLUDE_LPCUSECASEHANDLER_HPP diff --git a/modules/EnergyManagement/EEBUS/include/UseCaseEventReader.hpp b/modules/EnergyManagement/EEBUS/include/UseCaseEventReader.hpp new file mode 100644 index 0000000000..411dbeff2e --- /dev/null +++ b/modules/EnergyManagement/EEBUS/include/UseCaseEventReader.hpp @@ -0,0 +1,29 @@ +#ifndef USECASEEVENTREADER_HPP +#define USECASEEVENTREADER_HPP + +#include +#include + +#include + +class UseCaseEventReader : public grpc::ClientReadReactor { +public: + UseCaseEventReader(std::shared_ptr stub, + std::function event_callback); + + void start(const common_types::EntityAddress& entity_address, const control_service::UseCase& use_case); + void stop(); + + void OnReadDone(bool ok) override; + void OnDone(const grpc::Status& s) override; + +private: + std::shared_ptr stub; + std::function event_callback; + + grpc::ClientContext context; + control_service::SubscribeUseCaseEventsRequest request; + control_service::SubscribeUseCaseEventsResponse response; +}; + +#endif // USECASEEVENTREADER_HPP diff --git a/modules/EnergyManagement/EEBUS/include/helper.hpp b/modules/EnergyManagement/EEBUS/include/helper.hpp new file mode 100644 index 0000000000..6d18c4a863 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/include/helper.hpp @@ -0,0 +1,22 @@ +#ifndef MODULES_EEBUS_HELPER_HPP +#define MODULES_EEBUS_HELPER_HPP + +// everest core deps +#include + +// generated +#include "control_service/control_service.grpc.pb.h" +#include "usecases/cs/lpc/service.grpc.pb.h" + +// module internal +#include "EEBUS.hpp" + +namespace module { + +bool compare_use_case(const control_service::UseCase& uc1, const control_service::UseCase& uc2); + +types::energy::ExternalLimits translate_to_external_limits(const common_types::LoadLimit& load_limit); + +} // namespace module + +#endif diff --git a/modules/EnergyManagement/EEBUS/main/emptyImpl.cpp b/modules/EnergyManagement/EEBUS/main/emptyImpl.cpp new file mode 100644 index 0000000000..e69326b6ca --- /dev/null +++ b/modules/EnergyManagement/EEBUS/main/emptyImpl.cpp @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest + +#include "emptyImpl.hpp" + +namespace module { +namespace main { + +void emptyImpl::init() { +} + +void emptyImpl::ready() { +} + +} // namespace main +} // namespace module diff --git a/modules/EnergyManagement/EEBUS/main/emptyImpl.hpp b/modules/EnergyManagement/EEBUS/main/emptyImpl.hpp new file mode 100644 index 0000000000..176ae47235 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/main/emptyImpl.hpp @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright Pionix GmbH and Contributors to EVerest +#ifndef MAIN_EMPTY_IMPL_HPP +#define MAIN_EMPTY_IMPL_HPP + +// +// AUTO GENERATED - MARKED REGIONS WILL BE KEPT +// template version 3 +// + +#include + +#include "../EEBUS.hpp" + +// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1 +// insert your custom include headers here +// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1 + +namespace module { +namespace main { + +struct Conf {}; + +class emptyImpl : public emptyImplBase { +public: + emptyImpl() = delete; + emptyImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer& mod, Conf& config) : + emptyImplBase(ev, "main"), mod(mod), config(config){}; + + // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1 + // insert your public definitions here + // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1 + +protected: + // no commands defined for this interface + + // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1 + // insert your protected definitions here + // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1 + +private: + const Everest::PtrContainer& mod; + const Conf& config; + + virtual void init() override; + virtual void ready() override; + + // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1 + // insert your private definitions here + // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1 +}; + +// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1 +// insert other definitions here +// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1 + +} // namespace main +} // namespace module + +#endif // MAIN_EMPTY_IMPL_HPP diff --git a/modules/EnergyManagement/EEBUS/manifest.yaml b/modules/EnergyManagement/EEBUS/manifest.yaml new file mode 100644 index 0000000000..1c1aadcad3 --- /dev/null +++ b/modules/EnergyManagement/EEBUS/manifest.yaml @@ -0,0 +1,71 @@ +description: EEBUS module +config: + manage_eebus_grpc_api_binary: + description: Whether the module should manage the eebus grpc api binary + type: boolean + default: true + eebus_service_port: + description: Port for the control service, this will be sent in the SetConfig call. + type: integer + default: 4715 + grpc_port: + description: Port for grpc control service connection. This is the port on which we will create our control service channel and start the grpc binary with. + type: integer + default: 50051 + eebus_ems_ski: + description: EEBUS EMS SKI + type: string + required: true + certificate_path: + description: Path to the certificate file used by eebus go client. If relative will be prefixed with everest prefix + etc/everest/certs. Otherwise absolute file path is used. + type: string + required: false + default: eebus/evse_cert + private_key_path: + description: Path to the private key file used by eebus go client. If relative will be prefixed with everest prefix + etc/everest/certs. Otherwise absolute file path is used. + type: string + required: false + default: eebus/evse_key + eebus_grpc_api_binary_path: + description: Path to the eebus grpc api binary. If relative will be prefixed with everest prefix + libexec. Otherwise absolute file path is used. + type: string + required: false + default: eebus_grpc_api + vendor_code: + description: Vendor code for the configuration of the control service + type: string + required: true + device_brand: + description: Device brand for the configuration of the control service + type: string + required: true + device_model: + description: Device model for the configuration of the control service + type: string + required: true + serial_number: + description: Serial number for the configuration of the control service + type: string + required: true + failsafe_control_limit: + description: Failsafe control limit for LPC use case. This will also be used for the default consumption limit, unit is Watts + type: integer + default: 4200 + max_nominal_power: + description: Maximum nominal power of the charging station. This is the max power the CS can consume. + type: integer + default: 32000 +provides: + main: + description: main + interface: empty +requires: + eebus_energy_sink: + interface: external_energy_limits + min_connections: 1 + max_connections: 1 +metadata: + license: https://opensource.org/licenses/Apache-2.0 + authors: + - Andreas Heinrich + - Martin Litre diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index d9aefc5b45..1ff872f1b1 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -23,3 +23,4 @@ setup_target_for_coverage_gcovr_html( ) add_subdirectory(everest-core_tests) +add_subdirectory(eebus_tests) diff --git a/tests/eebus_tests/CMakeLists.txt b/tests/eebus_tests/CMakeLists.txt new file mode 100644 index 0000000000..2159ed4f4f --- /dev/null +++ b/tests/eebus_tests/CMakeLists.txt @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +add_subdirectory(grpc_libs) diff --git a/tests/eebus_tests/eebus_tests.py b/tests/eebus_tests/eebus_tests.py new file mode 100644 index 0000000000..1cc815a483 --- /dev/null +++ b/tests/eebus_tests/eebus_tests.py @@ -0,0 +1,606 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import logging +import pytest +import os +import pathlib +import asyncio +import datetime + +from everest.testing.core_utils.fixtures import * +from everest.testing.core_utils.everest_core import EverestCore +from everest.testing.core_utils.controller.everest_test_controller import EverestTestController + +from grpc_servicer.control_service_servicer import ControlServiceServicer +from grpc_server.control_service_server import ControlServiceServer +from grpc_servicer.cs_lpc_control_servicer import CsLpcControlServicer +from grpc_server.cs_lpc_control_server import CsLpcControlServer + +from fixtures.eebus_module_test import eebus_test_env, EebusTestProbeModule +from fixtures.grpc_testing_server import control_service_server, control_service_servicer, cs_lpc_control_server, cs_lpc_control_servicer +from helpers.import_helpers import insert_dir_to_sys_path +from helpers.async_helpers import async_get + +from test_data.test_data import TestData +from test_data.test_data_not_active_load_limit import TestDataNotActiveLoadLimit +from test_data.test_data_active_load_limit import TestDataActiveLoadLimit +from test_data.test_data_active_load_limit_with_duration import TestDataActiveLoadLimitWithDuration +from test_data.test_data_failsafe import TestDataFailsafe +from test_data.test_data_heartbeat import TestDataHeartbeat + +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 +import usecases.cs.lpc.messages_pb2 as cs_lpc_messages_pb2 +import control_service.types_pb2 as control_service_types_pb2 +import control_service.messages_pb2 as control_service_messages_pb2 + + +async def perform_eebus_handshake(control_service_servicer: ControlServiceServicer, cs_lpc_control_servicer: CsLpcControlServicer, cs_lpc_control_server: CsLpcControlServer, everest_core: EverestCore) -> EebusTestProbeModule: + """This helper function handles the complete EEBUS module init handshake and returns a started probe module.""" + + # Handle SetConfig + control_service_servicer.command_queues["SetConfig"].response_queue.put_nowait( + control_service_messages_pb2.EmptyResponse() + ) + req = await async_get(control_service_servicer.command_queues["SetConfig"].request_queue, timeout=10) + assert req is not None + assert req.port == 4715 + + # Start the probe module + probe = EebusTestProbeModule(everest_core.get_runtime_session()) + probe.start() + + # Handle StartSetup + req = await async_get(control_service_servicer.command_queues["StartSetup"].request_queue, timeout=5) + control_service_servicer.command_queues["StartSetup"].response_queue.put_nowait( + control_service_messages_pb2.EmptyResponse() + ) + + # Handle RegisterRemoteSki + req = await async_get(control_service_servicer.command_queues["RegisterRemoteSki"].request_queue, timeout=5) + control_service_servicer.command_queues["RegisterRemoteSki"].response_queue.put_nowait( + control_service_messages_pb2.EmptyResponse() + ) + + # Handle AddUseCase + req = await async_get(control_service_servicer.command_queues["AddUseCase"].request_queue, timeout=5) + res = control_service_messages_pb2.AddUseCaseResponse( + endpoint=f"localhost:{cs_lpc_control_server.get_port()}" + ) + control_service_servicer.command_queues["AddUseCase"].response_queue.put_nowait( + res) + + # Handle SetConsumptionNominalMax + req = await async_get(cs_lpc_control_servicer.command_queues["SetConsumptionNominalMax"].request_queue, timeout=5) + cs_lpc_control_servicer.command_queues["SetConsumptionNominalMax"].response_queue.put_nowait( + cs_lpc_messages_pb2.SetConsumptionNominalMaxResponse() + ) + + # Handle SetConsumptionLimit + req = await async_get(cs_lpc_control_servicer.command_queues["SetConsumptionLimit"].request_queue, timeout=5) + cs_lpc_control_servicer.command_queues["SetConsumptionLimit"].response_queue.put_nowait( + cs_lpc_messages_pb2.SetConsumptionLimitResponse() + ) + + # Handle SetFailsafeConsumptionActivePowerLimit + req = await async_get(cs_lpc_control_servicer.command_queues["SetFailsafeConsumptionActivePowerLimit"].request_queue, timeout=5) + cs_lpc_control_servicer.command_queues["SetFailsafeConsumptionActivePowerLimit"].response_queue.put_nowait( + cs_lpc_messages_pb2.SetFailsafeConsumptionActivePowerLimitResponse() + ) + + # Handle SetFailsafeDurationMinimum + req = await async_get(cs_lpc_control_servicer.command_queues["SetFailsafeDurationMinimum"].request_queue, timeout=5) + cs_lpc_control_servicer.command_queues["SetFailsafeDurationMinimum"].response_queue.put_nowait( + cs_lpc_messages_pb2.SetFailsafeDurationMinimumResponse() + ) + + # Handle StartService + req = await async_get(control_service_servicer.command_queues["StartService"].request_queue, timeout=5) + control_service_servicer.command_queues["StartService"].response_queue.put_nowait( + control_service_messages_pb2.EmptyResponse() + ) + + # Handle StartHeartbeat + req = await async_get(cs_lpc_control_servicer.command_queues["StartHeartbeat"].request_queue, timeout=5) + cs_lpc_control_servicer.command_queues["StartHeartbeat"].response_queue.put_nowait( + cs_lpc_messages_pb2.StartHeartbeatResponse() + ) + + await probe.wait_to_be_ready() + return probe + + +@pytest.mark.eebus_rpc_port(50051) +@pytest.mark.everest_core_config("config-test-eebus-module-001.yaml") +@pytest.mark.probe_module +class TestEEBUSModule: + """ + This test class is used to test the EEBUS module. + """ + @pytest.mark.parametrize( + "test_data", + [ + pytest.param( + TestDataNotActiveLoadLimit(), + id="not_active_load_limit", + ), + pytest.param( + TestDataActiveLoadLimit(), + id="active_load_limit", + ), + pytest.param( + TestDataActiveLoadLimitWithDuration(), + id="active_load_limit_with_duration", + ), + pytest.param( + TestDataFailsafe(), + id="failsafe_test_data", + ), + pytest.param( + TestDataHeartbeat(), + id="heartbeat_test_data", + ) + ] + ) + @pytest.mark.asyncio + async def test_set_load_limit( + self, + eebus_test_env: dict, + test_data: TestData, + ): + """ + This test sets the load limit and checks if the EEBUS module + sends the correct limits to the probe module. + """ + # Unpack the test environment from the fixture + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + # Perform the handshake and get the probe module + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # --- Handshake complete, now test the load limit logic --- + + # Simulate a WriteApprovalRequired event from the HEMS + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress( + entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="WriteApprovalRequired", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait( + uc_event) + + # The module should now ask for the pending limit + req = await async_get(cs_lpc_control_servicer.command_queues["PendingConsumptionLimit"].request_queue, timeout=5) + assert req is not None + + # We respond with the test data's limit + res = cs_lpc_messages_pb2.PendingConsumptionLimitResponse( + load_limits={0: test_data.get_load_limit()}) + cs_lpc_control_servicer.command_queues["PendingConsumptionLimit"].response_queue.put_nowait( + res) + + # The module should now approve the limit + req = await async_get(cs_lpc_control_servicer.command_queues["ApproveOrDenyConsumptionLimit"].request_queue, timeout=5) + assert req is not None + assert req.msg_counter == 0 + assert req.approve + cs_lpc_control_servicer.command_queues["ApproveOrDenyConsumptionLimit"].response_queue.put_nowait( + cs_lpc_messages_pb2.ApproveOrDenyConsumptionLimitResponse() + ) + + # Simulate a DataUpdateLimit event from the HEMS + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress( + entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateLimit", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait( + uc_event) + + # The module should now ask for the consumption limit + req = await async_get(cs_lpc_control_servicer.command_queues["ConsumptionLimit"].request_queue, timeout=5) + assert req is not None + + # We respond with the test data's limit + res = cs_lpc_messages_pb2.ConsumptionLimitResponse( + load_limit=test_data.get_load_limit(), + ) + cs_lpc_control_servicer.command_queues["ConsumptionLimit"].response_queue.put_nowait( + res) + + # Finally, the module should have sent the translated limits to our probe module + limits = await async_get(probe.external_limits_queue, timeout=2) + + assert test_data.get_expected_external_limits() == limits + test_data.run_additional_assertions(limits) + + @pytest.mark.asyncio + async def test_update_failsafe_duration_minimum( + self, + eebus_test_env: dict, + ): + """ + This test verifies that the failsafe duration minimum can be updated. + """ + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # Simulate a DataUpdateFailsafeDurationMinimum event + new_failsafe_duration_nanoseconds = 5 * 1000 * 1000 * 1000 # 5 seconds + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateFailsafeDurationMinimum", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + # The module should now ask for the failsafe duration minimum + req = await async_get(cs_lpc_control_servicer.command_queues["FailsafeDurationMinimum"].request_queue, timeout=5) + res = cs_lpc_messages_pb2.FailsafeDurationMinimumResponse( + duration_nanoseconds=new_failsafe_duration_nanoseconds, + is_changeable=True, + ) + cs_lpc_control_servicer.command_queues["FailsafeDurationMinimum"].response_queue.put_nowait(res) + + # Trigger failsafe state to check if the new duration is applied + # Simulate missing heartbeat + test_data_failsafe = TestDataFailsafe() + failsafe_limits = test_data_failsafe.get_expected_failsafe_limits(4200) # this is the config default + limits = await async_get(probe.external_limits_queue, timeout=65) # Wait for 60s + buffer + assert failsafe_limits == limits + + # Simulate a DataUpdateHeartbeat event + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateHeartbeat", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + await asyncio.sleep(55) + + # Simulate a DataUpdateHeartbeat event + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateHeartbeat", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + await asyncio.sleep(55) + + # Simulate a DataUpdateHeartbeat event + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateHeartbeat", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + # Now wait for the new failsafe duration to expire + unlimited_autonomous_limits = test_data_failsafe.get_expected_unlimited_autonomous_limits() + limits = await async_get(probe.external_limits_queue, timeout=20) # timeout after failsafe entry is 120s after duration minimum + assert unlimited_autonomous_limits == limits + + @pytest.mark.asyncio + async def test_update_failsafe_consumption_active_power_limit( + self, + eebus_test_env: dict, + ): + """ + This test verifies that the failsafe consumption active power limit can be updated. + """ + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # Simulate a DataUpdateFailsafeConsumptionActivePowerLimit event + new_failsafe_control_limit = 5000 + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateFailsafeConsumptionActivePowerLimit", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + # The module should now ask for the failsafe consumption active power limit + req = await async_get(cs_lpc_control_servicer.command_queues["FailsafeConsumptionActivePowerLimit"].request_queue, timeout=5) + res = cs_lpc_messages_pb2.FailsafeConsumptionActivePowerLimitResponse( + limit=new_failsafe_control_limit, + is_changeable=True, + ) + cs_lpc_control_servicer.command_queues["FailsafeConsumptionActivePowerLimit"].response_queue.put_nowait(res) + + # Trigger failsafe state to check if the new limit is applied + # Simulate missing heartbeat + test_data_failsafe = TestDataFailsafe() + failsafe_limits = test_data_failsafe.get_expected_failsafe_limits(new_failsafe_control_limit) + limits = await async_get(probe.external_limits_queue, timeout=65) + assert failsafe_limits == limits + + @pytest.mark.asyncio + async def test_failsafe_to_unlimited_controlled( + self, + eebus_test_env: dict, + ): + """ + This test verifies that the module transitions from failsafe to unlimited controlled + when a heartbeat is received. + """ + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # Simulate missing heartbeat to enter failsafe state + test_data_failsafe = TestDataFailsafe() + failsafe_limits = test_data_failsafe.get_expected_failsafe_limits(4200) + limits = await async_get(probe.external_limits_queue, timeout=65) # Wait for 60s + buffer + assert failsafe_limits == limits + + # Simulate a DataUpdateHeartbeat event + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateHeartbeat", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + # Simulate a WriteApprovalRequired event from the HEMS + uc_event_write_approval = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="WriteApprovalRequired", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event_write_approval) + + req_pending = await async_get(cs_lpc_control_servicer.command_queues["PendingConsumptionLimit"].request_queue, timeout=5) + res_pending = cs_lpc_messages_pb2.PendingConsumptionLimitResponse( + load_limits={0: common_types_pb2.LoadLimit(is_active=False, value=1000)} # Dummy limit + ) + cs_lpc_control_servicer.command_queues["PendingConsumptionLimit"].response_queue.put_nowait(res_pending) + + req_approve = await async_get(cs_lpc_control_servicer.command_queues["ApproveOrDenyConsumptionLimit"].request_queue, timeout=5) + assert req_approve.approve + cs_lpc_control_servicer.command_queues["ApproveOrDenyConsumptionLimit"].response_queue.put_nowait( + cs_lpc_messages_pb2.ApproveOrDenyConsumptionLimitResponse() + ) + # Simulate a DataUpdateLimit event to set an initial limit + test_data_active = TestDataActiveLoadLimit() + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateLimit", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + # The module should now ask for the consumption limit + req = await async_get(cs_lpc_control_servicer.command_queues["ConsumptionLimit"].request_queue, timeout=5) + assert req is not None + + # We respond with the test data's limit + res = cs_lpc_messages_pb2.ConsumptionLimitResponse( + load_limit=common_types_pb2.LoadLimit(is_active=False, value=1000), + ) + cs_lpc_control_servicer.command_queues["ConsumptionLimit"].response_queue.put_nowait( + res) + + # The module should transition to UnlimitedControlled state + test_data_not_active_load_limit = TestDataNotActiveLoadLimit() + unlimited_controlled_limits = test_data_not_active_load_limit.get_expected_external_limits() + limits = await async_get(probe.external_limits_queue, timeout=5) + assert unlimited_controlled_limits == limits + + @pytest.mark.asyncio + async def test_failsafe_to_limited( + self, + eebus_test_env: dict, + ): + """ + This test verifies that the module transitions from failsafe to unlimited controlled + when a heartbeat is received. + """ + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # Simulate missing heartbeat to enter failsafe state + test_data_failsafe = TestDataFailsafe() + failsafe_limits = test_data_failsafe.get_expected_failsafe_limits(4200) + limits = await async_get(probe.external_limits_queue, timeout=65) # Wait for 60s + buffer + assert failsafe_limits == limits + + # Simulate a DataUpdateHeartbeat event + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateHeartbeat", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + # Simulate a WriteApprovalRequired event from the HEMS + uc_event_write_approval = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="WriteApprovalRequired", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event_write_approval) + + test_data_active_load_limit = TestDataActiveLoadLimit() + req_pending = await async_get(cs_lpc_control_servicer.command_queues["PendingConsumptionLimit"].request_queue, timeout=5) + res_pending = cs_lpc_messages_pb2.PendingConsumptionLimitResponse( + load_limits={0: test_data_active_load_limit.get_load_limit()} # Dummy limit + ) + cs_lpc_control_servicer.command_queues["PendingConsumptionLimit"].response_queue.put_nowait(res_pending) + + req_approve = await async_get(cs_lpc_control_servicer.command_queues["ApproveOrDenyConsumptionLimit"].request_queue, timeout=5) + assert req_approve.approve + cs_lpc_control_servicer.command_queues["ApproveOrDenyConsumptionLimit"].response_queue.put_nowait( + cs_lpc_messages_pb2.ApproveOrDenyConsumptionLimitResponse() + ) + # Simulate a DataUpdateLimit event to set an initial limit + test_data_active = TestDataActiveLoadLimit() + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateLimit", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + # The module should now ask for the consumption limit + req = await async_get(cs_lpc_control_servicer.command_queues["ConsumptionLimit"].request_queue, timeout=5) + assert req is not None + + # We respond with the test data's limit + res = cs_lpc_messages_pb2.ConsumptionLimitResponse( + load_limit=test_data_active_load_limit.get_load_limit(), + ) + cs_lpc_control_servicer.command_queues["ConsumptionLimit"].response_queue.put_nowait( + res) + + # The module should transition to UnlimitedControlled state + limited_limits = test_data_active_load_limit.get_expected_external_limits() + limits = await async_get(probe.external_limits_queue, timeout=5) + assert limited_limits == limits + + @pytest.mark.asyncio + async def test_init_state_timeout( + self, + eebus_test_env: dict, + ): + """ + This test verifies that the module transitions from Init to UnlimitedAutonomous + if no events are received within LPC_TIMEOUT (120), but heartbeats are received as to not go into failsafe. + """ + everest_core = eebus_test_env["everest_core"] + control_service_servicer = eebus_test_env["control_service_servicer"] + cs_lpc_control_servicer = eebus_test_env["cs_lpc_control_servicer"] + cs_lpc_control_server = eebus_test_env["cs_lpc_control_server"] + + probe = await perform_eebus_handshake(control_service_servicer, cs_lpc_control_servicer, cs_lpc_control_server, everest_core) + + # Simulate a DataUpdateHeartbeat event + uc_event = control_service_messages_pb2.SubscribeUseCaseEventsResponse( + remote_ski="this-is-a-ski-42", + remote_entity_address=common_types_pb2.EntityAddress(entity_address=[1]), + use_case_event=control_service_types_pb2.UseCaseEvent( + use_case=control_service_types_pb2.UseCase( + actor=control_service_types_pb2.UseCase.ActorType.ControllableSystem, + name=control_service_types_pb2.UseCase.NameType.limitationOfPowerConsumption, + ), + event="DataUpdateHeartbeat", + ) + ) + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + await asyncio.sleep(50) + + # Simulate a new DataUpdateHeartbeat event + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + await asyncio.sleep(20) + + # Simulate a new DataUpdateHeartbeat event + control_service_servicer.command_queues["SubscribeUseCaseEvents"].response_queue.put_nowait(uc_event) + + # No limits are sent, so the module should transition from Init to UnlimitedAutonomous + # The limit would be the same as deactivated since there are no limits + test_data_not_active_load_limit = TestDataNotActiveLoadLimit() + unlimited_autonomous_limits = test_data_not_active_load_limit.get_expected_external_limits() + limits = await async_get(probe.external_limits_queue, timeout=125) + assert unlimited_autonomous_limits == limits + diff --git a/tests/eebus_tests/fixtures/__init__.py b/tests/eebus_tests/fixtures/__init__.py new file mode 100644 index 0000000000..112a431ac4 --- /dev/null +++ b/tests/eebus_tests/fixtures/__init__.py @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest diff --git a/tests/eebus_tests/fixtures/eebus_module_test.py b/tests/eebus_tests/fixtures/eebus_module_test.py new file mode 100644 index 0000000000..d94307b0bd --- /dev/null +++ b/tests/eebus_tests/fixtures/eebus_module_test.py @@ -0,0 +1,74 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import pytest_asyncio +import logging +import asyncio +import threading + +from everest.testing.core_utils.everest_core import EverestCore +from everest.testing.core_utils.probe_module import ProbeModule +from everest.testing.core_utils.controller.everest_test_controller import EverestTestController + +from grpc_servicer.control_service_servicer import ControlServiceServicer +from grpc_server.control_service_server import ControlServiceServer +from grpc_servicer.cs_lpc_control_servicer import CsLpcControlServicer +from grpc_server.cs_lpc_control_server import CsLpcControlServer + +from .grpc_testing_server import control_service_server, control_service_servicer, cs_lpc_control_server, cs_lpc_control_servicer +from helpers.conversions import convert_external_limits + + +class EebusTestProbeModule(ProbeModule): + """ + This class extends the ProbeModule to add a command for receiving + external limits from the EEBUS module. + """ + + def __init__(self, runtime_session): + super().__init__(runtime_session) + + super().implement_command( + "eebus_energy_sink", + "set_external_limits", + lambda arg: self._set_external_limits(arg), + ) + self.external_limits_queue = asyncio.Queue(maxsize=1) + + def _set_external_limits(self, limits): + logging.info(f"Set external limits: {limits}") + limits = convert_external_limits(limits) + self.external_limits_queue.put_nowait(limits) + + +@pytest_asyncio.fixture +async def eebus_test_env(everest_core: EverestCore, test_controller: EverestTestController, control_service_server: ControlServiceServer, cs_lpc_control_server: CsLpcControlServer, control_service_servicer: ControlServiceServicer, cs_lpc_control_servicer: CsLpcControlServicer): + """ + This fixture provides the basic test environment for the EEBUS module. + It starts EVerest and the mock gRPC servers. + """ + # Start everest in a thread so it doesn't block the event loop + everest_thread = threading.Thread(target=test_controller.start) + everest_thread.start() + + # The module will start initializing. The test function is now responsible for handling the handshake. + + test_env = { + "everest_core": everest_core, + "control_service_servicer": control_service_servicer, + "cs_lpc_control_servicer": cs_lpc_control_servicer, + "cs_lpc_control_server": cs_lpc_control_server, + } + + yield test_env + + # Teardown + logging.info("Tearing down EEBUSModuleTest fixture") + + # Stop the servicers and servers + control_service_servicer.stop() + await control_service_server.stop() + await cs_lpc_control_server.stop() + + # Stop the EVerest process first + test_controller.stop() diff --git a/tests/eebus_tests/fixtures/grpc_testing_server.py b/tests/eebus_tests/fixtures/grpc_testing_server.py new file mode 100644 index 0000000000..0f7c1fb858 --- /dev/null +++ b/tests/eebus_tests/fixtures/grpc_testing_server.py @@ -0,0 +1,50 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import pytest +import pytest_asyncio + +import grpc_servicer.control_service_servicer as control_service_servicer_module +import grpc_servicer.cs_lpc_control_servicer as cs_lpc_control_servicer_module +import grpc_server.control_service_server as control_service_server_module +import grpc_server.cs_lpc_control_server as cs_lpc_control_server_module + +@pytest.fixture +def control_service_servicer(): + """ + Provides a ControlServiceServicer instance for testing. + """ + return control_service_servicer_module.ControlServiceServicer() + +@pytest_asyncio.fixture +async def control_service_server(request, control_service_servicer): + """ + Provides an asyncio ControlServiceServer instance for testing that is automatically + started and stopped. + """ + rpc_port = request.node.get_closest_marker("eebus_rpc_port") + if rpc_port is None or len(rpc_port.args) == 0: + pytest.fail("No rpc port provided") + rpc_port = rpc_port.args[0] + server = control_service_server_module.ControlServiceServer(control_service_servicer, rpc_port) + await server.start() + yield server + await server.stop() + +@pytest.fixture +def cs_lpc_control_servicer(): + """ + Provides a CsLpcControlServicer instance for testing. + """ + return cs_lpc_control_servicer_module.CsLpcControlServicer() + +@pytest_asyncio.fixture +async def cs_lpc_control_server(cs_lpc_control_servicer): + """ + Provides an asyncio CsLpcControlServer instance for testing that is automatically + started and stopped. + """ + server = cs_lpc_control_server_module.CsLpcControlServer(cs_lpc_control_servicer) + await server.start() + yield server + await server.stop() \ No newline at end of file diff --git a/tests/eebus_tests/grpc_libs/CMakeLists.txt b/tests/eebus_tests/grpc_libs/CMakeLists.txt new file mode 100644 index 0000000000..744487ef80 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/CMakeLists.txt @@ -0,0 +1,53 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +set(GENERATED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/generated") + +setup_grpc() + +if (ENABLE_GRPC_GENERATOR) + if (NOT CPM_PACKAGE_eebus-grpc_SOURCE_DIR) + message(FATAL_ERROR "CPM_PACKAGE_eebus-grpc_SOURCE_DIR not set, it is required becaue it provides the protobuf files") + endif() + get_filename_component(PROTOBUF_DIR + "${CPM_PACKAGE_eebus-grpc_SOURCE_DIR}/protobuf/" + ABSOLUTE + ) + + setup_grpc_generator() + + generate_py_from_proto( + TARGET_NAME generate_proto_common_types_py + PROTOBUF_DIR ${PROTOBUF_DIR} + OUT_DIR ${GENERATED_DIR} + PROTO_FILES + "${PROTOBUF_DIR}/common_types/types.proto" + ) + + generate_py_from_proto( + TARGET_NAME generate_proto_control_service_py + PROTOBUF_DIR ${PROTOBUF_DIR} + OUT_DIR ${GENERATED_DIR} + PROTO_FILES + "${PROTOBUF_DIR}/control_service/control_service.proto" + "${PROTOBUF_DIR}/control_service/messages.proto" + "${PROTOBUF_DIR}/control_service/types.proto" + ) + + generate_py_from_proto( + TARGET_NAME generate_proto_cs_lpc_service_py + PROTOBUF_DIR ${PROTOBUF_DIR} + OUT_DIR ${GENERATED_DIR} + PROTO_FILES + "${PROTOBUF_DIR}/usecases/cs/lpc/service.proto" + "${PROTOBUF_DIR}/usecases/cs/lpc/messages.proto" + ) + + add_custom_target(generate_eebus_grpc_api_proto_py + ALL + DEPENDS + generate_proto_common_types_py + generate_proto_control_service_py + generate_proto_cs_lpc_service_py + ) +endif() diff --git a/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.py b/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.py new file mode 100644 index 0000000000..2c7908d619 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: common_types/types.proto +# Protobuf Python Version: 6.31.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 6, + 31, + 1, + '', + 'common_types/types.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x18\x63ommon_types/types.proto\x12\x0c\x63ommon_types\"{\n\tLoadLimit\x12\x1c\n\x14\x64uration_nanoseconds\x18\x01 \x01(\x03\x12\x15\n\ris_changeable\x18\x02 \x01(\x08\x12\x11\n\tis_active\x18\x03 \x01(\x08\x12\r\n\x05value\x18\x04 \x01(\x01\x12\x17\n\x0f\x64\x65lete_duration\x18\x05 \x01(\x08\"\'\n\rEntityAddress\x12\x16\n\x0e\x65ntity_address\x18\x01 \x03(\rB:Z8github.com/enbility/eebus-grpc/rpc_services/common_typesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'common_types.types_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z8github.com/enbility/eebus-grpc/rpc_services/common_types' + _globals['_LOADLIMIT']._serialized_start=42 + _globals['_LOADLIMIT']._serialized_end=165 + _globals['_ENTITYADDRESS']._serialized_start=167 + _globals['_ENTITYADDRESS']._serialized_end=206 +# @@protoc_insertion_point(module_scope) diff --git a/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.pyi b/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.pyi new file mode 100644 index 0000000000..8da2278410 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.pyi @@ -0,0 +1,27 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from collections.abc import Iterable as _Iterable +from typing import ClassVar as _ClassVar, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class LoadLimit(_message.Message): + __slots__ = ("duration_nanoseconds", "is_changeable", "is_active", "value", "delete_duration") + DURATION_NANOSECONDS_FIELD_NUMBER: _ClassVar[int] + IS_CHANGEABLE_FIELD_NUMBER: _ClassVar[int] + IS_ACTIVE_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + DELETE_DURATION_FIELD_NUMBER: _ClassVar[int] + duration_nanoseconds: int + is_changeable: bool + is_active: bool + value: float + delete_duration: bool + def __init__(self, duration_nanoseconds: _Optional[int] = ..., is_changeable: bool = ..., is_active: bool = ..., value: _Optional[float] = ..., delete_duration: bool = ...) -> None: ... + +class EntityAddress(_message.Message): + __slots__ = ("entity_address",) + ENTITY_ADDRESS_FIELD_NUMBER: _ClassVar[int] + entity_address: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, entity_address: _Optional[_Iterable[int]] = ...) -> None: ... diff --git a/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2_grpc.py b/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2_grpc.py new file mode 100644 index 0000000000..a8c7fef74b --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/common_types/types_pb2_grpc.py @@ -0,0 +1,24 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + + +GRPC_GENERATED_VERSION = '1.74.0' +GRPC_VERSION = grpc.__version__ +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + raise RuntimeError( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in common_types/types_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + ) diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.py b/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.py new file mode 100644 index 0000000000..ca33e81fc8 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: control_service/control_service.proto +# Protobuf Python Version: 6.31.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 6, + 31, + 1, + '', + 'control_service/control_service.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from control_service import messages_pb2 as control__service_dot_messages__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%control_service/control_service.proto\x12\x0f\x63ontrol_service\x1a\x1e\x63ontrol_service/messages.proto2\xb6\x06\n\x0e\x43ontrolService\x12O\n\x0cStartService\x12\x1d.control_service.EmptyRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12N\n\x0bStopService\x12\x1d.control_service.EmptyRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12P\n\tSetConfig\x12!.control_service.SetConfigRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12M\n\nStartSetup\x12\x1d.control_service.EmptyRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12P\n\tAddEntity\x12!.control_service.AddEntityRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12V\n\x0cRemoveEntity\x12$.control_service.RemoveEntityRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12`\n\x11RegisterRemoteSki\x12).control_service.RegisterRemoteSkiRequest\x1a\x1e.control_service.EmptyResponse\"\x00\x12W\n\nAddUseCase\x12\".control_service.AddUseCaseRequest\x1a#.control_service.AddUseCaseResponse\"\x00\x12}\n\x16SubscribeUseCaseEvents\x12..control_service.SubscribeUseCaseEventsRequest\x1a/.control_service.SubscribeUseCaseEventsResponse\"\x00\x30\x01\x42=Z;github.com/enbility/eebus-grpc/rpc_services/control_serviceb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'control_service.control_service_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z;github.com/enbility/eebus-grpc/rpc_services/control_service' + _globals['_CONTROLSERVICE']._serialized_start=91 + _globals['_CONTROLSERVICE']._serialized_end=913 +# @@protoc_insertion_point(module_scope) diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.pyi b/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.pyi new file mode 100644 index 0000000000..4c49c0edc6 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.pyi @@ -0,0 +1,5 @@ +from control_service import messages_pb2 as _messages_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2_grpc.py b/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2_grpc.py new file mode 100644 index 0000000000..dc801fece4 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2_grpc.py @@ -0,0 +1,451 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + +from control_service import messages_pb2 as control__service_dot_messages__pb2 + +GRPC_GENERATED_VERSION = '1.74.0' +GRPC_VERSION = grpc.__version__ +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + raise RuntimeError( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in control_service/control_service_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + ) + + +class ControlServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.StartService = channel.unary_unary( + '/control_service.ControlService/StartService', + request_serializer=control__service_dot_messages__pb2.EmptyRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.StopService = channel.unary_unary( + '/control_service.ControlService/StopService', + request_serializer=control__service_dot_messages__pb2.EmptyRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.SetConfig = channel.unary_unary( + '/control_service.ControlService/SetConfig', + request_serializer=control__service_dot_messages__pb2.SetConfigRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.StartSetup = channel.unary_unary( + '/control_service.ControlService/StartSetup', + request_serializer=control__service_dot_messages__pb2.EmptyRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.AddEntity = channel.unary_unary( + '/control_service.ControlService/AddEntity', + request_serializer=control__service_dot_messages__pb2.AddEntityRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.RemoveEntity = channel.unary_unary( + '/control_service.ControlService/RemoveEntity', + request_serializer=control__service_dot_messages__pb2.RemoveEntityRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.RegisterRemoteSki = channel.unary_unary( + '/control_service.ControlService/RegisterRemoteSki', + request_serializer=control__service_dot_messages__pb2.RegisterRemoteSkiRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.EmptyResponse.FromString, + _registered_method=True) + self.AddUseCase = channel.unary_unary( + '/control_service.ControlService/AddUseCase', + request_serializer=control__service_dot_messages__pb2.AddUseCaseRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.AddUseCaseResponse.FromString, + _registered_method=True) + self.SubscribeUseCaseEvents = channel.unary_stream( + '/control_service.ControlService/SubscribeUseCaseEvents', + request_serializer=control__service_dot_messages__pb2.SubscribeUseCaseEventsRequest.SerializeToString, + response_deserializer=control__service_dot_messages__pb2.SubscribeUseCaseEventsResponse.FromString, + _registered_method=True) + + +class ControlServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def StartService(self, request, context): + """Starts the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def StopService(self, request, context): + """Stops the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetConfig(self, request, context): + """Set Config for the EEBus service + Each parameter is optional. If a parameter is not set, the current value is used. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def StartSetup(self, request, context): + """Starts Setup() for the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AddEntity(self, request, context): + """Adds a new entity to the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RemoveEntity(self, request, context): + """Removes an entity from the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RegisterRemoteSki(self, request, context): + """Register remote SKI to the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AddUseCase(self, request, context): + """Adds an usecase to the EEBus service + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SubscribeUseCaseEvents(self, request, context): + """Subscribes to usecase events + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ControlServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'StartService': grpc.unary_unary_rpc_method_handler( + servicer.StartService, + request_deserializer=control__service_dot_messages__pb2.EmptyRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'StopService': grpc.unary_unary_rpc_method_handler( + servicer.StopService, + request_deserializer=control__service_dot_messages__pb2.EmptyRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'SetConfig': grpc.unary_unary_rpc_method_handler( + servicer.SetConfig, + request_deserializer=control__service_dot_messages__pb2.SetConfigRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'StartSetup': grpc.unary_unary_rpc_method_handler( + servicer.StartSetup, + request_deserializer=control__service_dot_messages__pb2.EmptyRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'AddEntity': grpc.unary_unary_rpc_method_handler( + servicer.AddEntity, + request_deserializer=control__service_dot_messages__pb2.AddEntityRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'RemoveEntity': grpc.unary_unary_rpc_method_handler( + servicer.RemoveEntity, + request_deserializer=control__service_dot_messages__pb2.RemoveEntityRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'RegisterRemoteSki': grpc.unary_unary_rpc_method_handler( + servicer.RegisterRemoteSki, + request_deserializer=control__service_dot_messages__pb2.RegisterRemoteSkiRequest.FromString, + response_serializer=control__service_dot_messages__pb2.EmptyResponse.SerializeToString, + ), + 'AddUseCase': grpc.unary_unary_rpc_method_handler( + servicer.AddUseCase, + request_deserializer=control__service_dot_messages__pb2.AddUseCaseRequest.FromString, + response_serializer=control__service_dot_messages__pb2.AddUseCaseResponse.SerializeToString, + ), + 'SubscribeUseCaseEvents': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeUseCaseEvents, + request_deserializer=control__service_dot_messages__pb2.SubscribeUseCaseEventsRequest.FromString, + response_serializer=control__service_dot_messages__pb2.SubscribeUseCaseEventsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'control_service.ControlService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + server.add_registered_method_handlers('control_service.ControlService', rpc_method_handlers) + + + # This class is part of an EXPERIMENTAL API. +class ControlService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def StartService(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/StartService', + control__service_dot_messages__pb2.EmptyRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def StopService(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/StopService', + control__service_dot_messages__pb2.EmptyRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/SetConfig', + control__service_dot_messages__pb2.SetConfigRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def StartSetup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/StartSetup', + control__service_dot_messages__pb2.EmptyRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def AddEntity(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/AddEntity', + control__service_dot_messages__pb2.AddEntityRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def RemoveEntity(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/RemoveEntity', + control__service_dot_messages__pb2.RemoveEntityRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def RegisterRemoteSki(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/RegisterRemoteSki', + control__service_dot_messages__pb2.RegisterRemoteSkiRequest.SerializeToString, + control__service_dot_messages__pb2.EmptyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def AddUseCase(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/control_service.ControlService/AddUseCase', + control__service_dot_messages__pb2.AddUseCaseRequest.SerializeToString, + control__service_dot_messages__pb2.AddUseCaseResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeUseCaseEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/control_service.ControlService/SubscribeUseCaseEvents', + control__service_dot_messages__pb2.SubscribeUseCaseEventsRequest.SerializeToString, + control__service_dot_messages__pb2.SubscribeUseCaseEventsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.py b/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.py new file mode 100644 index 0000000000..4599df1998 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: control_service/messages.proto +# Protobuf Python Version: 6.31.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 6, + 31, + 1, + '', + 'control_service/messages.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from control_service import types_pb2 as control__service_dot_types__pb2 +from common_types import types_pb2 as common__types_dot_types__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x63ontrol_service/messages.proto\x12\x0f\x63ontrol_service\x1a\x1b\x63ontrol_service/types.proto\x1a\x18\x63ommon_types/types.proto\"\x0e\n\x0c\x45mptyRequest\"\x0f\n\rEmptyResponse\"\xcb\x02\n\x10SetConfigRequest\x12\x0c\n\x04port\x18\x01 \x01(\r\x12\x13\n\x0bvendor_code\x18\x02 \x01(\t\x12\x14\n\x0c\x64\x65vice_brand\x18\x03 \x01(\t\x12\x14\n\x0c\x64\x65vice_model\x18\x04 \x01(\t\x12\x15\n\rserial_number\x18\x05 \x01(\t\x12?\n\x11\x64\x65vice_categories\x18\x06 \x03(\x0e\x32$.control_service.DeviceCategory.Enum\x12\x35\n\x0b\x64\x65vice_type\x18\x07 \x01(\x0e\x32 .control_service.DeviceType.Enum\x12\x36\n\x0c\x65ntity_types\x18\x08 \x03(\x0e\x32 .control_service.EntityType.Enum\x12!\n\x19heartbeat_timeout_seconds\x18\t \x01(\r\"p\n\x10\x41\x64\x64\x45ntityRequest\x12.\n\x04type\x18\x01 \x01(\x0e\x32 .control_service.EntityType.Enum\x12,\n\x07\x61\x64\x64ress\x18\x02 \x01(\x0b\x32\x1b.common_types.EntityAddress\"C\n\x13RemoveEntityRequest\x12,\n\x07\x61\x64\x64ress\x18\x01 \x01(\x0b\x32\x1b.common_types.EntityAddress\"t\n\x11\x41\x64\x64UseCaseRequest\x12\x33\n\x0e\x65ntity_address\x18\x01 \x01(\x0b\x32\x1b.common_types.EntityAddress\x12*\n\x08use_case\x18\x02 \x01(\x0b\x32\x18.control_service.UseCase\"&\n\x12\x41\x64\x64UseCaseResponse\x12\x10\n\x08\x65ndpoint\x18\x01 \x01(\t\".\n\x18RegisterRemoteSkiRequest\x12\x12\n\nremote_ski\x18\x01 \x01(\t\"\x80\x01\n\x1dSubscribeUseCaseEventsRequest\x12\x33\n\x0e\x65ntity_address\x18\x01 \x01(\x0b\x32\x1b.common_types.EntityAddress\x12*\n\x08use_case\x18\x02 \x01(\x0b\x32\x18.control_service.UseCase\"\xa7\x01\n\x1eSubscribeUseCaseEventsResponse\x12\x12\n\nremote_ski\x18\x01 \x01(\t\x12:\n\x15remote_entity_address\x18\x02 \x01(\x0b\x32\x1b.common_types.EntityAddress\x12\x35\n\x0euse_case_event\x18\x03 \x01(\x0b\x32\x1d.control_service.UseCaseEventB=Z;github.com/enbility/eebus-grpc/rpc_services/control_serviceb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'control_service.messages_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z;github.com/enbility/eebus-grpc/rpc_services/control_service' + _globals['_EMPTYREQUEST']._serialized_start=106 + _globals['_EMPTYREQUEST']._serialized_end=120 + _globals['_EMPTYRESPONSE']._serialized_start=122 + _globals['_EMPTYRESPONSE']._serialized_end=137 + _globals['_SETCONFIGREQUEST']._serialized_start=140 + _globals['_SETCONFIGREQUEST']._serialized_end=471 + _globals['_ADDENTITYREQUEST']._serialized_start=473 + _globals['_ADDENTITYREQUEST']._serialized_end=585 + _globals['_REMOVEENTITYREQUEST']._serialized_start=587 + _globals['_REMOVEENTITYREQUEST']._serialized_end=654 + _globals['_ADDUSECASEREQUEST']._serialized_start=656 + _globals['_ADDUSECASEREQUEST']._serialized_end=772 + _globals['_ADDUSECASERESPONSE']._serialized_start=774 + _globals['_ADDUSECASERESPONSE']._serialized_end=812 + _globals['_REGISTERREMOTESKIREQUEST']._serialized_start=814 + _globals['_REGISTERREMOTESKIREQUEST']._serialized_end=860 + _globals['_SUBSCRIBEUSECASEEVENTSREQUEST']._serialized_start=863 + _globals['_SUBSCRIBEUSECASEEVENTSREQUEST']._serialized_end=991 + _globals['_SUBSCRIBEUSECASEEVENTSRESPONSE']._serialized_start=994 + _globals['_SUBSCRIBEUSECASEEVENTSRESPONSE']._serialized_end=1161 +# @@protoc_insertion_point(module_scope) diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.pyi b/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.pyi new file mode 100644 index 0000000000..527181f490 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.pyi @@ -0,0 +1,91 @@ +from control_service import types_pb2 as _types_pb2 +from common_types import types_pb2 as _types_pb2_1 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from collections.abc import Iterable as _Iterable, Mapping as _Mapping +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class EmptyRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class EmptyResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class SetConfigRequest(_message.Message): + __slots__ = ("port", "vendor_code", "device_brand", "device_model", "serial_number", "device_categories", "device_type", "entity_types", "heartbeat_timeout_seconds") + PORT_FIELD_NUMBER: _ClassVar[int] + VENDOR_CODE_FIELD_NUMBER: _ClassVar[int] + DEVICE_BRAND_FIELD_NUMBER: _ClassVar[int] + DEVICE_MODEL_FIELD_NUMBER: _ClassVar[int] + SERIAL_NUMBER_FIELD_NUMBER: _ClassVar[int] + DEVICE_CATEGORIES_FIELD_NUMBER: _ClassVar[int] + DEVICE_TYPE_FIELD_NUMBER: _ClassVar[int] + ENTITY_TYPES_FIELD_NUMBER: _ClassVar[int] + HEARTBEAT_TIMEOUT_SECONDS_FIELD_NUMBER: _ClassVar[int] + port: int + vendor_code: str + device_brand: str + device_model: str + serial_number: str + device_categories: _containers.RepeatedScalarFieldContainer[_types_pb2.DeviceCategory.Enum] + device_type: _types_pb2.DeviceType.Enum + entity_types: _containers.RepeatedScalarFieldContainer[_types_pb2.EntityType.Enum] + heartbeat_timeout_seconds: int + def __init__(self, port: _Optional[int] = ..., vendor_code: _Optional[str] = ..., device_brand: _Optional[str] = ..., device_model: _Optional[str] = ..., serial_number: _Optional[str] = ..., device_categories: _Optional[_Iterable[_Union[_types_pb2.DeviceCategory.Enum, str]]] = ..., device_type: _Optional[_Union[_types_pb2.DeviceType.Enum, str]] = ..., entity_types: _Optional[_Iterable[_Union[_types_pb2.EntityType.Enum, str]]] = ..., heartbeat_timeout_seconds: _Optional[int] = ...) -> None: ... + +class AddEntityRequest(_message.Message): + __slots__ = ("type", "address") + TYPE_FIELD_NUMBER: _ClassVar[int] + ADDRESS_FIELD_NUMBER: _ClassVar[int] + type: _types_pb2.EntityType.Enum + address: _types_pb2_1.EntityAddress + def __init__(self, type: _Optional[_Union[_types_pb2.EntityType.Enum, str]] = ..., address: _Optional[_Union[_types_pb2_1.EntityAddress, _Mapping]] = ...) -> None: ... + +class RemoveEntityRequest(_message.Message): + __slots__ = ("address",) + ADDRESS_FIELD_NUMBER: _ClassVar[int] + address: _types_pb2_1.EntityAddress + def __init__(self, address: _Optional[_Union[_types_pb2_1.EntityAddress, _Mapping]] = ...) -> None: ... + +class AddUseCaseRequest(_message.Message): + __slots__ = ("entity_address", "use_case") + ENTITY_ADDRESS_FIELD_NUMBER: _ClassVar[int] + USE_CASE_FIELD_NUMBER: _ClassVar[int] + entity_address: _types_pb2_1.EntityAddress + use_case: _types_pb2.UseCase + def __init__(self, entity_address: _Optional[_Union[_types_pb2_1.EntityAddress, _Mapping]] = ..., use_case: _Optional[_Union[_types_pb2.UseCase, _Mapping]] = ...) -> None: ... + +class AddUseCaseResponse(_message.Message): + __slots__ = ("endpoint",) + ENDPOINT_FIELD_NUMBER: _ClassVar[int] + endpoint: str + def __init__(self, endpoint: _Optional[str] = ...) -> None: ... + +class RegisterRemoteSkiRequest(_message.Message): + __slots__ = ("remote_ski",) + REMOTE_SKI_FIELD_NUMBER: _ClassVar[int] + remote_ski: str + def __init__(self, remote_ski: _Optional[str] = ...) -> None: ... + +class SubscribeUseCaseEventsRequest(_message.Message): + __slots__ = ("entity_address", "use_case") + ENTITY_ADDRESS_FIELD_NUMBER: _ClassVar[int] + USE_CASE_FIELD_NUMBER: _ClassVar[int] + entity_address: _types_pb2_1.EntityAddress + use_case: _types_pb2.UseCase + def __init__(self, entity_address: _Optional[_Union[_types_pb2_1.EntityAddress, _Mapping]] = ..., use_case: _Optional[_Union[_types_pb2.UseCase, _Mapping]] = ...) -> None: ... + +class SubscribeUseCaseEventsResponse(_message.Message): + __slots__ = ("remote_ski", "remote_entity_address", "use_case_event") + REMOTE_SKI_FIELD_NUMBER: _ClassVar[int] + REMOTE_ENTITY_ADDRESS_FIELD_NUMBER: _ClassVar[int] + USE_CASE_EVENT_FIELD_NUMBER: _ClassVar[int] + remote_ski: str + remote_entity_address: _types_pb2_1.EntityAddress + use_case_event: _types_pb2.UseCaseEvent + def __init__(self, remote_ski: _Optional[str] = ..., remote_entity_address: _Optional[_Union[_types_pb2_1.EntityAddress, _Mapping]] = ..., use_case_event: _Optional[_Union[_types_pb2.UseCaseEvent, _Mapping]] = ...) -> None: ... diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2_grpc.py b/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2_grpc.py new file mode 100644 index 0000000000..3a00cd9b55 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2_grpc.py @@ -0,0 +1,24 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + + +GRPC_GENERATED_VERSION = '1.74.0' +GRPC_VERSION = grpc.__version__ +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + raise RuntimeError( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in control_service/messages_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + ) diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/types_pb2.py b/tests/eebus_tests/grpc_libs/generated/control_service/types_pb2.py new file mode 100644 index 0000000000..feab29442d --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/types_pb2.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: control_service/types.proto +# Protobuf Python Version: 6.31.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 6, + 31, + 1, + '', + 'control_service/types.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x63ontrol_service/types.proto\x12\x0f\x63ontrol_service\"\xab\x01\n\x0e\x44\x65viceCategory\"\x98\x01\n\x04\x45num\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x17\n\x13GRID_CONNECTION_HUB\x10\x01\x12\x1c\n\x18\x45NERGY_MANAGEMENT_SYSTEM\x10\x02\x12\x0e\n\nE_MOBILITY\x10\x03\x12\x08\n\x04HVAC\x10\x04\x12\x0c\n\x08INVERTER\x10\x05\x12\x16\n\x12\x44OMESTIC_APPLIANCE\x10\x06\x12\x0c\n\x08METERING\x10\x07\"\xb2\x07\n\nEntityType\"\xa3\x07\n\x04\x45num\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07\x42\x61ttery\x10\x01\x12\x0e\n\nCompressor\x10\x02\x12\x15\n\x11\x44\x65viceInformation\x10\x03\x12\x0e\n\nDHWCircuit\x10\x04\x12\x0e\n\nDHWStorage\x10\x05\x12\x0e\n\nDishwasher\x10\x06\x12\t\n\x05\x44ryer\x10\x07\x12\x1d\n\x19\x45lectricalImmersionHeater\x10\x08\x12\x07\n\x03\x46\x61n\x10\t\x12\x17\n\x13GasHeatingAppliance\x10\n\x12\x0b\n\x07Generic\x10\x0b\x12\x18\n\x14HeatingBufferStorage\x10\x0c\x12\x12\n\x0eHeatingCircuit\x10\r\x12\x11\n\rHeatingObject\x10\x0e\x12\x0f\n\x0bHeatingZone\x10\x0f\x12\x15\n\x11HeatPumpAppliance\x10\x10\x12\x13\n\x0fHeatSinkCircuit\x10\x11\x12\x15\n\x11HeatSourceCircuit\x10\x12\x12\x12\n\x0eHeatSourceUnit\x10\x13\x12\x12\n\x0eHvacController\x10\x14\x12\x0c\n\x08HvacRoom\x10\x15\x12\x14\n\x10InstantDHWHeater\x10\x16\x12\x0c\n\x08Inverter\x10\x17\x12\x17\n\x13OilHeatingAppliance\x10\x18\x12\x08\n\x04Pump\x10\x19\x12\x16\n\x12RefrigerantCircuit\x10\x1a\x12\x18\n\x14SmartEnergyAppliance\x10\x1b\x12\x13\n\x0fSolarDHWStorage\x10\x1c\x12\x17\n\x13SolarThermalCircuit\x10\x1d\x12\x17\n\x13SubMeterElectricity\x10\x1e\x12\x15\n\x11TemperatureSensor\x10\x1f\x12\n\n\x06Washer\x10 \x12\x11\n\rBatterySystem\x10!\x12\x1f\n\x1b\x45lectricityGenerationSystem\x10\"\x12\x1c\n\x18\x45lectricityStorageSystem\x10#\x12!\n\x1dGridConnectionPointOfPremises\x10$\x12\r\n\tHousehold\x10%\x12\x0c\n\x08PVSystem\x10&\x12\x06\n\x02\x45V\x10\'\x12\x08\n\x04\x45VSE\x10(\x12\x12\n\x0e\x43hargingOutlet\x10)\x12\x07\n\x03\x43\x45M\x10*\x12\x06\n\x02PV\x10+\x12\x0e\n\nPVESHybrid\x10,\x12\x15\n\x11\x45lectricalStorage\x10-\x12\x0c\n\x08PVString\x10.\x12\r\n\tGridGuard\x10/\x12\x16\n\x12\x43ontrollableSystem\x10\x30\"\xbd\x02\n\nDeviceType\"\xae\x02\n\x04\x45num\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0e\n\nDISHWASHER\x10\x01\x12\t\n\x05\x44RYER\x10\x02\x12\x16\n\x12\x45NVIRONMENT_SENSOR\x10\x03\x12\x0b\n\x07GENERIC\x10\x04\x12\x1a\n\x16HEAT_GENERATION_SYSTEM\x10\x05\x12\x14\n\x10HEAT_SINK_SYSTEM\x10\x06\x12\x17\n\x13HEAT_STORAGE_SYSTEM\x10\x07\x12\x13\n\x0fHVAC_CONTROLLER\x10\x08\x12\x0c\n\x08SUBMETER\x10\t\x12\n\n\x06WASHER\x10\n\x12\x1d\n\x19\x45LECTRICITY_SUPPLY_SYSTEM\x10\x0b\x12\x1c\n\x18\x45NERGY_MANAGEMENT_SYSTEM\x10\x0c\x12\x0c\n\x08INVERTER\x10\r\x12\x14\n\x10\x43HARGING_STATION\x10\x0e\"\xca\x0f\n\x07UseCase\x12\x36\n\x05\x61\x63tor\x18\x01 \x01(\x0e\x32\'.control_service.UseCase.ActorType.Enum\x12\x34\n\x04name\x18\x02 \x01(\x0e\x32&.control_service.UseCase.NameType.Enum\x1a\xe5\x03\n\tActorType\"\xd7\x03\n\x04\x45num\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07\x42\x61ttery\x10\x01\x12\x11\n\rBatterySystem\x10\x02\x12\x07\n\x03\x43\x45M\x10\x03\x12\x1a\n\x16\x43onfigurationAppliance\x10\x04\x12\x0e\n\nCompressor\x10\x05\x12\x16\n\x12\x43ontrollableSystem\x10\x06\x12\x0e\n\nDHWCircuit\x10\x07\x12\x10\n\x0c\x45nergyBroker\x10\x08\x12\x12\n\x0e\x45nergyConsumer\x10\t\x12\x0f\n\x0b\x45nergyGuard\x10\n\x12\x08\n\x04\x45VSE\x10\x0b\x12\x06\n\x02\x45V\x10\x0c\x12\x17\n\x13GridConnectionPoint\x10\r\x12\x0c\n\x08HeatPump\x10\x0e\x12\x12\n\x0eHeatingCircuit\x10\x0f\x12\x0f\n\x0bHeatingZone\x10\x10\x12\x0c\n\x08HVACRoom\x10\x11\x12\x0c\n\x08Inverter\x10\x12\x12\x11\n\rMonitoredUnit\x10\x13\x12\x17\n\x13MonitoringAppliance\x10\x14\x12\x1c\n\x18OutdoorTemperatureSensor\x10\x15\x12\x0c\n\x08PVString\x10\x16\x12\x0c\n\x08PVSystem\x10\x17\x12\x12\n\x0eSmartAppliance\x10\x18\x12\x1a\n\x16VisualizationAppliance\x10\x19\x1a\xe8\n\n\x08NameType\"\xdb\n\n\x04\x45num\x12\x0b\n\x07UNKNOWN\x10\x00\x12$\n configurationOfDhwSystemFunction\x10\x01\x12!\n\x1d\x63onfigurationOfDhwTemperature\x10\x02\x12,\n(configurationOfRoomCoolingSystemFunction\x10\x03\x12)\n%configurationOfRoomCoolingTemperature\x10\x04\x12,\n(configurationOfRoomHeatingSystemFunction\x10\x05\x12)\n%configurationOfRoomHeatingTemperature\x10\x06\x12\x14\n\x10\x63ontrolOfBattery\x10\x07\x12\x19\n\x15\x63oordinatedEvCharging\x10\x08\x12\x15\n\x11\x65vChargingSummary\x10\t\x12#\n\x1f\x65vCommissioningAndConfiguration\x10\n\x12%\n!evseCommissioningAndConfiguration\x10\x0b\x12\x13\n\x0f\x65vStateOfCharge\x10\x0c\x12\x10\n\x0c\x66lexibleLoad\x10\r\x12\x1e\n\x1a\x66lexibleStartForWhiteGoods\x10\x0e\x12 \n\x1climitationOfPowerConsumption\x10\x0f\x12\x1f\n\x1blimitationOfPowerProduction\x10\x10\x12\x31\n-incentiveTableBasedPowerConsumptionManagement\x10\x11\x12,\n(measurementOfElectricityDuringEvCharging\x10\x12\x12\x32\n.monitoringAndControlOfSmartGridReadyConditions\x10\x13\x12\x17\n\x13monitoringOfBattery\x10\x14\x12!\n\x1dmonitoringOfDhwSystemFunction\x10\x15\x12\x1e\n\x1amonitoringOfDhwTemperature\x10\x16\x12#\n\x1fmonitoringOfGridConnectionPoint\x10\x17\x12\x18\n\x14monitoringOfInverter\x10\x18\x12\"\n\x1emonitoringOfOutdoorTemperature\x10\x19\x12 \n\x1cmonitoringOfPowerConsumption\x10\x1a\x12\x18\n\x14monitoringOfPvString\x10\x1b\x12)\n%monitoringOfRoomCoolingSystemFunction\x10\x1c\x12)\n%monitoringOfRoomHeatingSystemFunction\x10\x1d\x12\x1f\n\x1bmonitoringOfRoomTemperature\x10\x1e\x12@\n None: ... + +class EntityType(_message.Message): + __slots__ = () + class Enum(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UNKNOWN: _ClassVar[EntityType.Enum] + Battery: _ClassVar[EntityType.Enum] + Compressor: _ClassVar[EntityType.Enum] + DeviceInformation: _ClassVar[EntityType.Enum] + DHWCircuit: _ClassVar[EntityType.Enum] + DHWStorage: _ClassVar[EntityType.Enum] + Dishwasher: _ClassVar[EntityType.Enum] + Dryer: _ClassVar[EntityType.Enum] + ElectricalImmersionHeater: _ClassVar[EntityType.Enum] + Fan: _ClassVar[EntityType.Enum] + GasHeatingAppliance: _ClassVar[EntityType.Enum] + Generic: _ClassVar[EntityType.Enum] + HeatingBufferStorage: _ClassVar[EntityType.Enum] + HeatingCircuit: _ClassVar[EntityType.Enum] + HeatingObject: _ClassVar[EntityType.Enum] + HeatingZone: _ClassVar[EntityType.Enum] + HeatPumpAppliance: _ClassVar[EntityType.Enum] + HeatSinkCircuit: _ClassVar[EntityType.Enum] + HeatSourceCircuit: _ClassVar[EntityType.Enum] + HeatSourceUnit: _ClassVar[EntityType.Enum] + HvacController: _ClassVar[EntityType.Enum] + HvacRoom: _ClassVar[EntityType.Enum] + InstantDHWHeater: _ClassVar[EntityType.Enum] + Inverter: _ClassVar[EntityType.Enum] + OilHeatingAppliance: _ClassVar[EntityType.Enum] + Pump: _ClassVar[EntityType.Enum] + RefrigerantCircuit: _ClassVar[EntityType.Enum] + SmartEnergyAppliance: _ClassVar[EntityType.Enum] + SolarDHWStorage: _ClassVar[EntityType.Enum] + SolarThermalCircuit: _ClassVar[EntityType.Enum] + SubMeterElectricity: _ClassVar[EntityType.Enum] + TemperatureSensor: _ClassVar[EntityType.Enum] + Washer: _ClassVar[EntityType.Enum] + BatterySystem: _ClassVar[EntityType.Enum] + ElectricityGenerationSystem: _ClassVar[EntityType.Enum] + ElectricityStorageSystem: _ClassVar[EntityType.Enum] + GridConnectionPointOfPremises: _ClassVar[EntityType.Enum] + Household: _ClassVar[EntityType.Enum] + PVSystem: _ClassVar[EntityType.Enum] + EV: _ClassVar[EntityType.Enum] + EVSE: _ClassVar[EntityType.Enum] + ChargingOutlet: _ClassVar[EntityType.Enum] + CEM: _ClassVar[EntityType.Enum] + PV: _ClassVar[EntityType.Enum] + PVESHybrid: _ClassVar[EntityType.Enum] + ElectricalStorage: _ClassVar[EntityType.Enum] + PVString: _ClassVar[EntityType.Enum] + GridGuard: _ClassVar[EntityType.Enum] + ControllableSystem: _ClassVar[EntityType.Enum] + UNKNOWN: EntityType.Enum + Battery: EntityType.Enum + Compressor: EntityType.Enum + DeviceInformation: EntityType.Enum + DHWCircuit: EntityType.Enum + DHWStorage: EntityType.Enum + Dishwasher: EntityType.Enum + Dryer: EntityType.Enum + ElectricalImmersionHeater: EntityType.Enum + Fan: EntityType.Enum + GasHeatingAppliance: EntityType.Enum + Generic: EntityType.Enum + HeatingBufferStorage: EntityType.Enum + HeatingCircuit: EntityType.Enum + HeatingObject: EntityType.Enum + HeatingZone: EntityType.Enum + HeatPumpAppliance: EntityType.Enum + HeatSinkCircuit: EntityType.Enum + HeatSourceCircuit: EntityType.Enum + HeatSourceUnit: EntityType.Enum + HvacController: EntityType.Enum + HvacRoom: EntityType.Enum + InstantDHWHeater: EntityType.Enum + Inverter: EntityType.Enum + OilHeatingAppliance: EntityType.Enum + Pump: EntityType.Enum + RefrigerantCircuit: EntityType.Enum + SmartEnergyAppliance: EntityType.Enum + SolarDHWStorage: EntityType.Enum + SolarThermalCircuit: EntityType.Enum + SubMeterElectricity: EntityType.Enum + TemperatureSensor: EntityType.Enum + Washer: EntityType.Enum + BatterySystem: EntityType.Enum + ElectricityGenerationSystem: EntityType.Enum + ElectricityStorageSystem: EntityType.Enum + GridConnectionPointOfPremises: EntityType.Enum + Household: EntityType.Enum + PVSystem: EntityType.Enum + EV: EntityType.Enum + EVSE: EntityType.Enum + ChargingOutlet: EntityType.Enum + CEM: EntityType.Enum + PV: EntityType.Enum + PVESHybrid: EntityType.Enum + ElectricalStorage: EntityType.Enum + PVString: EntityType.Enum + GridGuard: EntityType.Enum + ControllableSystem: EntityType.Enum + def __init__(self) -> None: ... + +class DeviceType(_message.Message): + __slots__ = () + class Enum(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UNKNOWN: _ClassVar[DeviceType.Enum] + DISHWASHER: _ClassVar[DeviceType.Enum] + DRYER: _ClassVar[DeviceType.Enum] + ENVIRONMENT_SENSOR: _ClassVar[DeviceType.Enum] + GENERIC: _ClassVar[DeviceType.Enum] + HEAT_GENERATION_SYSTEM: _ClassVar[DeviceType.Enum] + HEAT_SINK_SYSTEM: _ClassVar[DeviceType.Enum] + HEAT_STORAGE_SYSTEM: _ClassVar[DeviceType.Enum] + HVAC_CONTROLLER: _ClassVar[DeviceType.Enum] + SUBMETER: _ClassVar[DeviceType.Enum] + WASHER: _ClassVar[DeviceType.Enum] + ELECTRICITY_SUPPLY_SYSTEM: _ClassVar[DeviceType.Enum] + ENERGY_MANAGEMENT_SYSTEM: _ClassVar[DeviceType.Enum] + INVERTER: _ClassVar[DeviceType.Enum] + CHARGING_STATION: _ClassVar[DeviceType.Enum] + UNKNOWN: DeviceType.Enum + DISHWASHER: DeviceType.Enum + DRYER: DeviceType.Enum + ENVIRONMENT_SENSOR: DeviceType.Enum + GENERIC: DeviceType.Enum + HEAT_GENERATION_SYSTEM: DeviceType.Enum + HEAT_SINK_SYSTEM: DeviceType.Enum + HEAT_STORAGE_SYSTEM: DeviceType.Enum + HVAC_CONTROLLER: DeviceType.Enum + SUBMETER: DeviceType.Enum + WASHER: DeviceType.Enum + ELECTRICITY_SUPPLY_SYSTEM: DeviceType.Enum + ENERGY_MANAGEMENT_SYSTEM: DeviceType.Enum + INVERTER: DeviceType.Enum + CHARGING_STATION: DeviceType.Enum + def __init__(self) -> None: ... + +class UseCase(_message.Message): + __slots__ = ("actor", "name") + class ActorType(_message.Message): + __slots__ = () + class Enum(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UNKNOWN: _ClassVar[UseCase.ActorType.Enum] + Battery: _ClassVar[UseCase.ActorType.Enum] + BatterySystem: _ClassVar[UseCase.ActorType.Enum] + CEM: _ClassVar[UseCase.ActorType.Enum] + ConfigurationAppliance: _ClassVar[UseCase.ActorType.Enum] + Compressor: _ClassVar[UseCase.ActorType.Enum] + ControllableSystem: _ClassVar[UseCase.ActorType.Enum] + DHWCircuit: _ClassVar[UseCase.ActorType.Enum] + EnergyBroker: _ClassVar[UseCase.ActorType.Enum] + EnergyConsumer: _ClassVar[UseCase.ActorType.Enum] + EnergyGuard: _ClassVar[UseCase.ActorType.Enum] + EVSE: _ClassVar[UseCase.ActorType.Enum] + EV: _ClassVar[UseCase.ActorType.Enum] + GridConnectionPoint: _ClassVar[UseCase.ActorType.Enum] + HeatPump: _ClassVar[UseCase.ActorType.Enum] + HeatingCircuit: _ClassVar[UseCase.ActorType.Enum] + HeatingZone: _ClassVar[UseCase.ActorType.Enum] + HVACRoom: _ClassVar[UseCase.ActorType.Enum] + Inverter: _ClassVar[UseCase.ActorType.Enum] + MonitoredUnit: _ClassVar[UseCase.ActorType.Enum] + MonitoringAppliance: _ClassVar[UseCase.ActorType.Enum] + OutdoorTemperatureSensor: _ClassVar[UseCase.ActorType.Enum] + PVString: _ClassVar[UseCase.ActorType.Enum] + PVSystem: _ClassVar[UseCase.ActorType.Enum] + SmartAppliance: _ClassVar[UseCase.ActorType.Enum] + VisualizationAppliance: _ClassVar[UseCase.ActorType.Enum] + UNKNOWN: UseCase.ActorType.Enum + Battery: UseCase.ActorType.Enum + BatterySystem: UseCase.ActorType.Enum + CEM: UseCase.ActorType.Enum + ConfigurationAppliance: UseCase.ActorType.Enum + Compressor: UseCase.ActorType.Enum + ControllableSystem: UseCase.ActorType.Enum + DHWCircuit: UseCase.ActorType.Enum + EnergyBroker: UseCase.ActorType.Enum + EnergyConsumer: UseCase.ActorType.Enum + EnergyGuard: UseCase.ActorType.Enum + EVSE: UseCase.ActorType.Enum + EV: UseCase.ActorType.Enum + GridConnectionPoint: UseCase.ActorType.Enum + HeatPump: UseCase.ActorType.Enum + HeatingCircuit: UseCase.ActorType.Enum + HeatingZone: UseCase.ActorType.Enum + HVACRoom: UseCase.ActorType.Enum + Inverter: UseCase.ActorType.Enum + MonitoredUnit: UseCase.ActorType.Enum + MonitoringAppliance: UseCase.ActorType.Enum + OutdoorTemperatureSensor: UseCase.ActorType.Enum + PVString: UseCase.ActorType.Enum + PVSystem: UseCase.ActorType.Enum + SmartAppliance: UseCase.ActorType.Enum + VisualizationAppliance: UseCase.ActorType.Enum + def __init__(self) -> None: ... + class NameType(_message.Message): + __slots__ = () + class Enum(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UNKNOWN: _ClassVar[UseCase.NameType.Enum] + configurationOfDhwSystemFunction: _ClassVar[UseCase.NameType.Enum] + configurationOfDhwTemperature: _ClassVar[UseCase.NameType.Enum] + configurationOfRoomCoolingSystemFunction: _ClassVar[UseCase.NameType.Enum] + configurationOfRoomCoolingTemperature: _ClassVar[UseCase.NameType.Enum] + configurationOfRoomHeatingSystemFunction: _ClassVar[UseCase.NameType.Enum] + configurationOfRoomHeatingTemperature: _ClassVar[UseCase.NameType.Enum] + controlOfBattery: _ClassVar[UseCase.NameType.Enum] + coordinatedEvCharging: _ClassVar[UseCase.NameType.Enum] + evChargingSummary: _ClassVar[UseCase.NameType.Enum] + evCommissioningAndConfiguration: _ClassVar[UseCase.NameType.Enum] + evseCommissioningAndConfiguration: _ClassVar[UseCase.NameType.Enum] + evStateOfCharge: _ClassVar[UseCase.NameType.Enum] + flexibleLoad: _ClassVar[UseCase.NameType.Enum] + flexibleStartForWhiteGoods: _ClassVar[UseCase.NameType.Enum] + limitationOfPowerConsumption: _ClassVar[UseCase.NameType.Enum] + limitationOfPowerProduction: _ClassVar[UseCase.NameType.Enum] + incentiveTableBasedPowerConsumptionManagement: _ClassVar[UseCase.NameType.Enum] + measurementOfElectricityDuringEvCharging: _ClassVar[UseCase.NameType.Enum] + monitoringAndControlOfSmartGridReadyConditions: _ClassVar[UseCase.NameType.Enum] + monitoringOfBattery: _ClassVar[UseCase.NameType.Enum] + monitoringOfDhwSystemFunction: _ClassVar[UseCase.NameType.Enum] + monitoringOfDhwTemperature: _ClassVar[UseCase.NameType.Enum] + monitoringOfGridConnectionPoint: _ClassVar[UseCase.NameType.Enum] + monitoringOfInverter: _ClassVar[UseCase.NameType.Enum] + monitoringOfOutdoorTemperature: _ClassVar[UseCase.NameType.Enum] + monitoringOfPowerConsumption: _ClassVar[UseCase.NameType.Enum] + monitoringOfPvString: _ClassVar[UseCase.NameType.Enum] + monitoringOfRoomCoolingSystemFunction: _ClassVar[UseCase.NameType.Enum] + monitoringOfRoomHeatingSystemFunction: _ClassVar[UseCase.NameType.Enum] + monitoringOfRoomTemperature: _ClassVar[UseCase.NameType.Enum] + optimizationOfSelfConsumptionByHeatPumpCompressorFlexibility: _ClassVar[UseCase.NameType.Enum] + optimizationOfSelfConsumptionDuringEvCharging: _ClassVar[UseCase.NameType.Enum] + overloadProtectionByEvChargingCurrentCurtailment: _ClassVar[UseCase.NameType.Enum] + visualizationOfAggregatedBatteryData: _ClassVar[UseCase.NameType.Enum] + visualizationOfAggregatedPhotovoltaicData: _ClassVar[UseCase.NameType.Enum] + visualizationOfHeatingAreaName: _ClassVar[UseCase.NameType.Enum] + UNKNOWN: UseCase.NameType.Enum + configurationOfDhwSystemFunction: UseCase.NameType.Enum + configurationOfDhwTemperature: UseCase.NameType.Enum + configurationOfRoomCoolingSystemFunction: UseCase.NameType.Enum + configurationOfRoomCoolingTemperature: UseCase.NameType.Enum + configurationOfRoomHeatingSystemFunction: UseCase.NameType.Enum + configurationOfRoomHeatingTemperature: UseCase.NameType.Enum + controlOfBattery: UseCase.NameType.Enum + coordinatedEvCharging: UseCase.NameType.Enum + evChargingSummary: UseCase.NameType.Enum + evCommissioningAndConfiguration: UseCase.NameType.Enum + evseCommissioningAndConfiguration: UseCase.NameType.Enum + evStateOfCharge: UseCase.NameType.Enum + flexibleLoad: UseCase.NameType.Enum + flexibleStartForWhiteGoods: UseCase.NameType.Enum + limitationOfPowerConsumption: UseCase.NameType.Enum + limitationOfPowerProduction: UseCase.NameType.Enum + incentiveTableBasedPowerConsumptionManagement: UseCase.NameType.Enum + measurementOfElectricityDuringEvCharging: UseCase.NameType.Enum + monitoringAndControlOfSmartGridReadyConditions: UseCase.NameType.Enum + monitoringOfBattery: UseCase.NameType.Enum + monitoringOfDhwSystemFunction: UseCase.NameType.Enum + monitoringOfDhwTemperature: UseCase.NameType.Enum + monitoringOfGridConnectionPoint: UseCase.NameType.Enum + monitoringOfInverter: UseCase.NameType.Enum + monitoringOfOutdoorTemperature: UseCase.NameType.Enum + monitoringOfPowerConsumption: UseCase.NameType.Enum + monitoringOfPvString: UseCase.NameType.Enum + monitoringOfRoomCoolingSystemFunction: UseCase.NameType.Enum + monitoringOfRoomHeatingSystemFunction: UseCase.NameType.Enum + monitoringOfRoomTemperature: UseCase.NameType.Enum + optimizationOfSelfConsumptionByHeatPumpCompressorFlexibility: UseCase.NameType.Enum + optimizationOfSelfConsumptionDuringEvCharging: UseCase.NameType.Enum + overloadProtectionByEvChargingCurrentCurtailment: UseCase.NameType.Enum + visualizationOfAggregatedBatteryData: UseCase.NameType.Enum + visualizationOfAggregatedPhotovoltaicData: UseCase.NameType.Enum + visualizationOfHeatingAreaName: UseCase.NameType.Enum + def __init__(self) -> None: ... + ACTOR_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + actor: UseCase.ActorType.Enum + name: UseCase.NameType.Enum + def __init__(self, actor: _Optional[_Union[UseCase.ActorType.Enum, str]] = ..., name: _Optional[_Union[UseCase.NameType.Enum, str]] = ...) -> None: ... + +class UseCaseEvent(_message.Message): + __slots__ = ("use_case", "event") + USE_CASE_FIELD_NUMBER: _ClassVar[int] + EVENT_FIELD_NUMBER: _ClassVar[int] + use_case: UseCase + event: str + def __init__(self, use_case: _Optional[_Union[UseCase, _Mapping]] = ..., event: _Optional[str] = ...) -> None: ... diff --git a/tests/eebus_tests/grpc_libs/generated/control_service/types_pb2_grpc.py b/tests/eebus_tests/grpc_libs/generated/control_service/types_pb2_grpc.py new file mode 100644 index 0000000000..9306a546f4 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/control_service/types_pb2_grpc.py @@ -0,0 +1,24 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + + +GRPC_GENERATED_VERSION = '1.74.0' +GRPC_VERSION = grpc.__version__ +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + raise RuntimeError( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in control_service/types_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + ) diff --git a/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.py b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.py new file mode 100644 index 0000000000..feb157680f --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.py @@ -0,0 +1,92 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: usecases/cs/lpc/messages.proto +# Protobuf Python Version: 6.31.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 6, + 31, + 1, + '', + 'usecases/cs/lpc/messages.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from common_types import types_pb2 as common__types_dot_types__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1eusecases/cs/lpc/messages.proto\x12\x06\x63s_lpc\x1a\x18\x63ommon_types/types.proto\"\x19\n\x17\x43onsumptionLimitRequest\"G\n\x18\x43onsumptionLimitResponse\x12+\n\nload_limit\x18\x01 \x01(\x0b\x32\x17.common_types.LoadLimit\"I\n\x1aSetConsumptionLimitRequest\x12+\n\nload_limit\x18\x01 \x01(\x0b\x32\x17.common_types.LoadLimit\"\x1d\n\x1bSetConsumptionLimitResponse\" \n\x1ePendingConsumptionLimitRequest\"\xbb\x01\n\x1fPendingConsumptionLimitResponse\x12L\n\x0bload_limits\x18\x01 \x03(\x0b\x32\x37.cs_lpc.PendingConsumptionLimitResponse.LoadLimitsEntry\x1aJ\n\x0fLoadLimitsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12&\n\x05value\x18\x02 \x01(\x0b\x32\x17.common_types.LoadLimit:\x02\x38\x01\"\\\n$ApproveOrDenyConsumptionLimitRequest\x12\x13\n\x0bmsg_counter\x18\x01 \x01(\x04\x12\x0f\n\x07\x61pprove\x18\x02 \x01(\x08\x12\x0e\n\x06reason\x18\x03 \x01(\t\"\'\n%ApproveOrDenyConsumptionLimitResponse\",\n*FailsafeConsumptionActivePowerLimitRequest\"S\n+FailsafeConsumptionActivePowerLimitResponse\x12\r\n\x05limit\x18\x01 \x01(\x01\x12\x15\n\ris_changeable\x18\x02 \x01(\x08\"U\n-SetFailsafeConsumptionActivePowerLimitRequest\x12\r\n\x05value\x18\x01 \x01(\x01\x12\x15\n\ris_changeable\x18\x02 \x01(\x08\"0\n.SetFailsafeConsumptionActivePowerLimitResponse\" \n\x1e\x46\x61ilsafeDurationMinimumRequest\"V\n\x1f\x46\x61ilsafeDurationMinimumResponse\x12\x1c\n\x14\x64uration_nanoseconds\x18\x01 \x01(\x03\x12\x15\n\ris_changeable\x18\x02 \x01(\x08\"X\n!SetFailsafeDurationMinimumRequest\x12\x1c\n\x14\x64uration_nanoseconds\x18\x01 \x01(\x03\x12\x15\n\ris_changeable\x18\x02 \x01(\x08\"$\n\"SetFailsafeDurationMinimumResponse\"\x17\n\x15StartHeartbeatRequest\"\x18\n\x16StartHeartbeatResponse\"\x16\n\x14StopHeartbeatRequest\"\x17\n\x15StopHeartbeatResponse\"\"\n IsHeartbeatWithinDurationRequest\"?\n!IsHeartbeatWithinDurationResponse\x12\x1a\n\x12is_within_duration\x18\x01 \x01(\x08\"\x1e\n\x1c\x43onsumptionNominalMaxRequest\".\n\x1d\x43onsumptionNominalMaxResponse\x12\r\n\x05value\x18\x01 \x01(\x01\"0\n\x1fSetConsumptionNominalMaxRequest\x12\r\n\x05value\x18\x01 \x01(\x01\"\"\n SetConsumptionNominalMaxResponseB=Z;github.com/enbility/eebus-grpc/rpc_services/usecases/cs/lpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'usecases.cs.lpc.messages_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z;github.com/enbility/eebus-grpc/rpc_services/usecases/cs/lpc' + _globals['_PENDINGCONSUMPTIONLIMITRESPONSE_LOADLIMITSENTRY']._loaded_options = None + _globals['_PENDINGCONSUMPTIONLIMITRESPONSE_LOADLIMITSENTRY']._serialized_options = b'8\001' + _globals['_CONSUMPTIONLIMITREQUEST']._serialized_start=68 + _globals['_CONSUMPTIONLIMITREQUEST']._serialized_end=93 + _globals['_CONSUMPTIONLIMITRESPONSE']._serialized_start=95 + _globals['_CONSUMPTIONLIMITRESPONSE']._serialized_end=166 + _globals['_SETCONSUMPTIONLIMITREQUEST']._serialized_start=168 + _globals['_SETCONSUMPTIONLIMITREQUEST']._serialized_end=241 + _globals['_SETCONSUMPTIONLIMITRESPONSE']._serialized_start=243 + _globals['_SETCONSUMPTIONLIMITRESPONSE']._serialized_end=272 + _globals['_PENDINGCONSUMPTIONLIMITREQUEST']._serialized_start=274 + _globals['_PENDINGCONSUMPTIONLIMITREQUEST']._serialized_end=306 + _globals['_PENDINGCONSUMPTIONLIMITRESPONSE']._serialized_start=309 + _globals['_PENDINGCONSUMPTIONLIMITRESPONSE']._serialized_end=496 + _globals['_PENDINGCONSUMPTIONLIMITRESPONSE_LOADLIMITSENTRY']._serialized_start=422 + _globals['_PENDINGCONSUMPTIONLIMITRESPONSE_LOADLIMITSENTRY']._serialized_end=496 + _globals['_APPROVEORDENYCONSUMPTIONLIMITREQUEST']._serialized_start=498 + _globals['_APPROVEORDENYCONSUMPTIONLIMITREQUEST']._serialized_end=590 + _globals['_APPROVEORDENYCONSUMPTIONLIMITRESPONSE']._serialized_start=592 + _globals['_APPROVEORDENYCONSUMPTIONLIMITRESPONSE']._serialized_end=631 + _globals['_FAILSAFECONSUMPTIONACTIVEPOWERLIMITREQUEST']._serialized_start=633 + _globals['_FAILSAFECONSUMPTIONACTIVEPOWERLIMITREQUEST']._serialized_end=677 + _globals['_FAILSAFECONSUMPTIONACTIVEPOWERLIMITRESPONSE']._serialized_start=679 + _globals['_FAILSAFECONSUMPTIONACTIVEPOWERLIMITRESPONSE']._serialized_end=762 + _globals['_SETFAILSAFECONSUMPTIONACTIVEPOWERLIMITREQUEST']._serialized_start=764 + _globals['_SETFAILSAFECONSUMPTIONACTIVEPOWERLIMITREQUEST']._serialized_end=849 + _globals['_SETFAILSAFECONSUMPTIONACTIVEPOWERLIMITRESPONSE']._serialized_start=851 + _globals['_SETFAILSAFECONSUMPTIONACTIVEPOWERLIMITRESPONSE']._serialized_end=899 + _globals['_FAILSAFEDURATIONMINIMUMREQUEST']._serialized_start=901 + _globals['_FAILSAFEDURATIONMINIMUMREQUEST']._serialized_end=933 + _globals['_FAILSAFEDURATIONMINIMUMRESPONSE']._serialized_start=935 + _globals['_FAILSAFEDURATIONMINIMUMRESPONSE']._serialized_end=1021 + _globals['_SETFAILSAFEDURATIONMINIMUMREQUEST']._serialized_start=1023 + _globals['_SETFAILSAFEDURATIONMINIMUMREQUEST']._serialized_end=1111 + _globals['_SETFAILSAFEDURATIONMINIMUMRESPONSE']._serialized_start=1113 + _globals['_SETFAILSAFEDURATIONMINIMUMRESPONSE']._serialized_end=1149 + _globals['_STARTHEARTBEATREQUEST']._serialized_start=1151 + _globals['_STARTHEARTBEATREQUEST']._serialized_end=1174 + _globals['_STARTHEARTBEATRESPONSE']._serialized_start=1176 + _globals['_STARTHEARTBEATRESPONSE']._serialized_end=1200 + _globals['_STOPHEARTBEATREQUEST']._serialized_start=1202 + _globals['_STOPHEARTBEATREQUEST']._serialized_end=1224 + _globals['_STOPHEARTBEATRESPONSE']._serialized_start=1226 + _globals['_STOPHEARTBEATRESPONSE']._serialized_end=1249 + _globals['_ISHEARTBEATWITHINDURATIONREQUEST']._serialized_start=1251 + _globals['_ISHEARTBEATWITHINDURATIONREQUEST']._serialized_end=1285 + _globals['_ISHEARTBEATWITHINDURATIONRESPONSE']._serialized_start=1287 + _globals['_ISHEARTBEATWITHINDURATIONRESPONSE']._serialized_end=1350 + _globals['_CONSUMPTIONNOMINALMAXREQUEST']._serialized_start=1352 + _globals['_CONSUMPTIONNOMINALMAXREQUEST']._serialized_end=1382 + _globals['_CONSUMPTIONNOMINALMAXRESPONSE']._serialized_start=1384 + _globals['_CONSUMPTIONNOMINALMAXRESPONSE']._serialized_end=1430 + _globals['_SETCONSUMPTIONNOMINALMAXREQUEST']._serialized_start=1432 + _globals['_SETCONSUMPTIONNOMINALMAXREQUEST']._serialized_end=1480 + _globals['_SETCONSUMPTIONNOMINALMAXRESPONSE']._serialized_start=1482 + _globals['_SETCONSUMPTIONNOMINALMAXRESPONSE']._serialized_end=1516 +# @@protoc_insertion_point(module_scope) diff --git a/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.pyi b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.pyi new file mode 100644 index 0000000000..430513eceb --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.pyi @@ -0,0 +1,153 @@ +from common_types import types_pb2 as _types_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from collections.abc import Mapping as _Mapping +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ConsumptionLimitRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class ConsumptionLimitResponse(_message.Message): + __slots__ = ("load_limit",) + LOAD_LIMIT_FIELD_NUMBER: _ClassVar[int] + load_limit: _types_pb2.LoadLimit + def __init__(self, load_limit: _Optional[_Union[_types_pb2.LoadLimit, _Mapping]] = ...) -> None: ... + +class SetConsumptionLimitRequest(_message.Message): + __slots__ = ("load_limit",) + LOAD_LIMIT_FIELD_NUMBER: _ClassVar[int] + load_limit: _types_pb2.LoadLimit + def __init__(self, load_limit: _Optional[_Union[_types_pb2.LoadLimit, _Mapping]] = ...) -> None: ... + +class SetConsumptionLimitResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class PendingConsumptionLimitRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class PendingConsumptionLimitResponse(_message.Message): + __slots__ = ("load_limits",) + class LoadLimitsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: _types_pb2.LoadLimit + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[_types_pb2.LoadLimit, _Mapping]] = ...) -> None: ... + LOAD_LIMITS_FIELD_NUMBER: _ClassVar[int] + load_limits: _containers.MessageMap[int, _types_pb2.LoadLimit] + def __init__(self, load_limits: _Optional[_Mapping[int, _types_pb2.LoadLimit]] = ...) -> None: ... + +class ApproveOrDenyConsumptionLimitRequest(_message.Message): + __slots__ = ("msg_counter", "approve", "reason") + MSG_COUNTER_FIELD_NUMBER: _ClassVar[int] + APPROVE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + msg_counter: int + approve: bool + reason: str + def __init__(self, msg_counter: _Optional[int] = ..., approve: bool = ..., reason: _Optional[str] = ...) -> None: ... + +class ApproveOrDenyConsumptionLimitResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class FailsafeConsumptionActivePowerLimitRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class FailsafeConsumptionActivePowerLimitResponse(_message.Message): + __slots__ = ("limit", "is_changeable") + LIMIT_FIELD_NUMBER: _ClassVar[int] + IS_CHANGEABLE_FIELD_NUMBER: _ClassVar[int] + limit: float + is_changeable: bool + def __init__(self, limit: _Optional[float] = ..., is_changeable: bool = ...) -> None: ... + +class SetFailsafeConsumptionActivePowerLimitRequest(_message.Message): + __slots__ = ("value", "is_changeable") + VALUE_FIELD_NUMBER: _ClassVar[int] + IS_CHANGEABLE_FIELD_NUMBER: _ClassVar[int] + value: float + is_changeable: bool + def __init__(self, value: _Optional[float] = ..., is_changeable: bool = ...) -> None: ... + +class SetFailsafeConsumptionActivePowerLimitResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class FailsafeDurationMinimumRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class FailsafeDurationMinimumResponse(_message.Message): + __slots__ = ("duration_nanoseconds", "is_changeable") + DURATION_NANOSECONDS_FIELD_NUMBER: _ClassVar[int] + IS_CHANGEABLE_FIELD_NUMBER: _ClassVar[int] + duration_nanoseconds: int + is_changeable: bool + def __init__(self, duration_nanoseconds: _Optional[int] = ..., is_changeable: bool = ...) -> None: ... + +class SetFailsafeDurationMinimumRequest(_message.Message): + __slots__ = ("duration_nanoseconds", "is_changeable") + DURATION_NANOSECONDS_FIELD_NUMBER: _ClassVar[int] + IS_CHANGEABLE_FIELD_NUMBER: _ClassVar[int] + duration_nanoseconds: int + is_changeable: bool + def __init__(self, duration_nanoseconds: _Optional[int] = ..., is_changeable: bool = ...) -> None: ... + +class SetFailsafeDurationMinimumResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class StartHeartbeatRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class StartHeartbeatResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class StopHeartbeatRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class StopHeartbeatResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class IsHeartbeatWithinDurationRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class IsHeartbeatWithinDurationResponse(_message.Message): + __slots__ = ("is_within_duration",) + IS_WITHIN_DURATION_FIELD_NUMBER: _ClassVar[int] + is_within_duration: bool + def __init__(self, is_within_duration: bool = ...) -> None: ... + +class ConsumptionNominalMaxRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class ConsumptionNominalMaxResponse(_message.Message): + __slots__ = ("value",) + VALUE_FIELD_NUMBER: _ClassVar[int] + value: float + def __init__(self, value: _Optional[float] = ...) -> None: ... + +class SetConsumptionNominalMaxRequest(_message.Message): + __slots__ = ("value",) + VALUE_FIELD_NUMBER: _ClassVar[int] + value: float + def __init__(self, value: _Optional[float] = ...) -> None: ... + +class SetConsumptionNominalMaxResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... diff --git a/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2_grpc.py b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2_grpc.py new file mode 100644 index 0000000000..14338454c3 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2_grpc.py @@ -0,0 +1,24 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + + +GRPC_GENERATED_VERSION = '1.74.0' +GRPC_VERSION = grpc.__version__ +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + raise RuntimeError( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in usecases/cs/lpc/messages_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + ) diff --git a/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.py b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.py new file mode 100644 index 0000000000..3aa8face89 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: usecases/cs/lpc/service.proto +# Protobuf Python Version: 6.31.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 6, + 31, + 1, + '', + 'usecases/cs/lpc/service.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from usecases.cs.lpc import messages_pb2 as usecases_dot_cs_dot_lpc_dot_messages__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dusecases/cs/lpc/service.proto\x12\x06\x63s_lpc\x1a\x1eusecases/cs/lpc/messages.proto2\xcb\x0b\n\x1c\x43ontrollableSystemLPCControl\x12W\n\x10\x43onsumptionLimit\x12\x1f.cs_lpc.ConsumptionLimitRequest\x1a .cs_lpc.ConsumptionLimitResponse\"\x00\x12`\n\x13SetConsumptionLimit\x12\".cs_lpc.SetConsumptionLimitRequest\x1a#.cs_lpc.SetConsumptionLimitResponse\"\x00\x12l\n\x17PendingConsumptionLimit\x12&.cs_lpc.PendingConsumptionLimitRequest\x1a\'.cs_lpc.PendingConsumptionLimitResponse\"\x00\x12~\n\x1d\x41pproveOrDenyConsumptionLimit\x12,.cs_lpc.ApproveOrDenyConsumptionLimitRequest\x1a-.cs_lpc.ApproveOrDenyConsumptionLimitResponse\"\x00\x12\x90\x01\n#FailsafeConsumptionActivePowerLimit\x12\x32.cs_lpc.FailsafeConsumptionActivePowerLimitRequest\x1a\x33.cs_lpc.FailsafeConsumptionActivePowerLimitResponse\"\x00\x12\x99\x01\n&SetFailsafeConsumptionActivePowerLimit\x12\x35.cs_lpc.SetFailsafeConsumptionActivePowerLimitRequest\x1a\x36.cs_lpc.SetFailsafeConsumptionActivePowerLimitResponse\"\x00\x12l\n\x17\x46\x61ilsafeDurationMinimum\x12&.cs_lpc.FailsafeDurationMinimumRequest\x1a\'.cs_lpc.FailsafeDurationMinimumResponse\"\x00\x12u\n\x1aSetFailsafeDurationMinimum\x12).cs_lpc.SetFailsafeDurationMinimumRequest\x1a*.cs_lpc.SetFailsafeDurationMinimumResponse\"\x00\x12Q\n\x0eStartHeartbeat\x12\x1d.cs_lpc.StartHeartbeatRequest\x1a\x1e.cs_lpc.StartHeartbeatResponse\"\x00\x12N\n\rStopHeartbeat\x12\x1c.cs_lpc.StopHeartbeatRequest\x1a\x1d.cs_lpc.StopHeartbeatResponse\"\x00\x12r\n\x19IsHeartbeatWithinDuration\x12(.cs_lpc.IsHeartbeatWithinDurationRequest\x1a).cs_lpc.IsHeartbeatWithinDurationResponse\"\x00\x12\x66\n\x15\x43onsumptionNominalMax\x12$.cs_lpc.ConsumptionNominalMaxRequest\x1a%.cs_lpc.ConsumptionNominalMaxResponse\"\x00\x12o\n\x18SetConsumptionNominalMax\x12\'.cs_lpc.SetConsumptionNominalMaxRequest\x1a(.cs_lpc.SetConsumptionNominalMaxResponse\"\x00\x42=Z;github.com/enbility/eebus-grpc/rpc_services/usecases/cs/lpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'usecases.cs.lpc.service_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z;github.com/enbility/eebus-grpc/rpc_services/usecases/cs/lpc' + _globals['_CONTROLLABLESYSTEMLPCCONTROL']._serialized_start=74 + _globals['_CONTROLLABLESYSTEMLPCCONTROL']._serialized_end=1557 +# @@protoc_insertion_point(module_scope) diff --git a/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.pyi b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.pyi new file mode 100644 index 0000000000..871d2f8a6a --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.pyi @@ -0,0 +1,5 @@ +from usecases.cs.lpc import messages_pb2 as _messages_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2_grpc.py b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2_grpc.py new file mode 100644 index 0000000000..805e1a7d58 --- /dev/null +++ b/tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2_grpc.py @@ -0,0 +1,613 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + +from usecases.cs.lpc import messages_pb2 as usecases_dot_cs_dot_lpc_dot_messages__pb2 + +GRPC_GENERATED_VERSION = '1.74.0' +GRPC_VERSION = grpc.__version__ +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + raise RuntimeError( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in usecases/cs/lpc/service_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + ) + + +class ControllableSystemLPCControlStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ConsumptionLimit = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/ConsumptionLimit', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionLimitRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionLimitResponse.FromString, + _registered_method=True) + self.SetConsumptionLimit = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/SetConsumptionLimit', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionLimitRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionLimitResponse.FromString, + _registered_method=True) + self.PendingConsumptionLimit = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/PendingConsumptionLimit', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.PendingConsumptionLimitRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.PendingConsumptionLimitResponse.FromString, + _registered_method=True) + self.ApproveOrDenyConsumptionLimit = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/ApproveOrDenyConsumptionLimit', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ApproveOrDenyConsumptionLimitRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ApproveOrDenyConsumptionLimitResponse.FromString, + _registered_method=True) + self.FailsafeConsumptionActivePowerLimit = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/FailsafeConsumptionActivePowerLimit', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeConsumptionActivePowerLimitRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeConsumptionActivePowerLimitResponse.FromString, + _registered_method=True) + self.SetFailsafeConsumptionActivePowerLimit = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/SetFailsafeConsumptionActivePowerLimit', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeConsumptionActivePowerLimitRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeConsumptionActivePowerLimitResponse.FromString, + _registered_method=True) + self.FailsafeDurationMinimum = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/FailsafeDurationMinimum', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeDurationMinimumRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeDurationMinimumResponse.FromString, + _registered_method=True) + self.SetFailsafeDurationMinimum = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/SetFailsafeDurationMinimum', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeDurationMinimumRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeDurationMinimumResponse.FromString, + _registered_method=True) + self.StartHeartbeat = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/StartHeartbeat', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StartHeartbeatRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StartHeartbeatResponse.FromString, + _registered_method=True) + self.StopHeartbeat = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/StopHeartbeat', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StopHeartbeatRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StopHeartbeatResponse.FromString, + _registered_method=True) + self.IsHeartbeatWithinDuration = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/IsHeartbeatWithinDuration', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.IsHeartbeatWithinDurationRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.IsHeartbeatWithinDurationResponse.FromString, + _registered_method=True) + self.ConsumptionNominalMax = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/ConsumptionNominalMax', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionNominalMaxRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionNominalMaxResponse.FromString, + _registered_method=True) + self.SetConsumptionNominalMax = channel.unary_unary( + '/cs_lpc.ControllableSystemLPCControl/SetConsumptionNominalMax', + request_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionNominalMaxRequest.SerializeToString, + response_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionNominalMaxResponse.FromString, + _registered_method=True) + + +class ControllableSystemLPCControlServicer(object): + """Missing associated documentation comment in .proto file.""" + + def ConsumptionLimit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetConsumptionLimit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PendingConsumptionLimit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ApproveOrDenyConsumptionLimit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FailsafeConsumptionActivePowerLimit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetFailsafeConsumptionActivePowerLimit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FailsafeDurationMinimum(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetFailsafeDurationMinimum(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def StartHeartbeat(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def StopHeartbeat(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def IsHeartbeatWithinDuration(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ConsumptionNominalMax(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetConsumptionNominalMax(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ControllableSystemLPCControlServicer_to_server(servicer, server): + rpc_method_handlers = { + 'ConsumptionLimit': grpc.unary_unary_rpc_method_handler( + servicer.ConsumptionLimit, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionLimitRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionLimitResponse.SerializeToString, + ), + 'SetConsumptionLimit': grpc.unary_unary_rpc_method_handler( + servicer.SetConsumptionLimit, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionLimitRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionLimitResponse.SerializeToString, + ), + 'PendingConsumptionLimit': grpc.unary_unary_rpc_method_handler( + servicer.PendingConsumptionLimit, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.PendingConsumptionLimitRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.PendingConsumptionLimitResponse.SerializeToString, + ), + 'ApproveOrDenyConsumptionLimit': grpc.unary_unary_rpc_method_handler( + servicer.ApproveOrDenyConsumptionLimit, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ApproveOrDenyConsumptionLimitRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ApproveOrDenyConsumptionLimitResponse.SerializeToString, + ), + 'FailsafeConsumptionActivePowerLimit': grpc.unary_unary_rpc_method_handler( + servicer.FailsafeConsumptionActivePowerLimit, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeConsumptionActivePowerLimitRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeConsumptionActivePowerLimitResponse.SerializeToString, + ), + 'SetFailsafeConsumptionActivePowerLimit': grpc.unary_unary_rpc_method_handler( + servicer.SetFailsafeConsumptionActivePowerLimit, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeConsumptionActivePowerLimitRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeConsumptionActivePowerLimitResponse.SerializeToString, + ), + 'FailsafeDurationMinimum': grpc.unary_unary_rpc_method_handler( + servicer.FailsafeDurationMinimum, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeDurationMinimumRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeDurationMinimumResponse.SerializeToString, + ), + 'SetFailsafeDurationMinimum': grpc.unary_unary_rpc_method_handler( + servicer.SetFailsafeDurationMinimum, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeDurationMinimumRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeDurationMinimumResponse.SerializeToString, + ), + 'StartHeartbeat': grpc.unary_unary_rpc_method_handler( + servicer.StartHeartbeat, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StartHeartbeatRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StartHeartbeatResponse.SerializeToString, + ), + 'StopHeartbeat': grpc.unary_unary_rpc_method_handler( + servicer.StopHeartbeat, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StopHeartbeatRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.StopHeartbeatResponse.SerializeToString, + ), + 'IsHeartbeatWithinDuration': grpc.unary_unary_rpc_method_handler( + servicer.IsHeartbeatWithinDuration, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.IsHeartbeatWithinDurationRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.IsHeartbeatWithinDurationResponse.SerializeToString, + ), + 'ConsumptionNominalMax': grpc.unary_unary_rpc_method_handler( + servicer.ConsumptionNominalMax, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionNominalMaxRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionNominalMaxResponse.SerializeToString, + ), + 'SetConsumptionNominalMax': grpc.unary_unary_rpc_method_handler( + servicer.SetConsumptionNominalMax, + request_deserializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionNominalMaxRequest.FromString, + response_serializer=usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionNominalMaxResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'cs_lpc.ControllableSystemLPCControl', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + server.add_registered_method_handlers('cs_lpc.ControllableSystemLPCControl', rpc_method_handlers) + + + # This class is part of an EXPERIMENTAL API. +class ControllableSystemLPCControl(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def ConsumptionLimit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/ConsumptionLimit', + usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionLimitRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionLimitResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetConsumptionLimit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/SetConsumptionLimit', + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionLimitRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionLimitResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def PendingConsumptionLimit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/PendingConsumptionLimit', + usecases_dot_cs_dot_lpc_dot_messages__pb2.PendingConsumptionLimitRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.PendingConsumptionLimitResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ApproveOrDenyConsumptionLimit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/ApproveOrDenyConsumptionLimit', + usecases_dot_cs_dot_lpc_dot_messages__pb2.ApproveOrDenyConsumptionLimitRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.ApproveOrDenyConsumptionLimitResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def FailsafeConsumptionActivePowerLimit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/FailsafeConsumptionActivePowerLimit', + usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeConsumptionActivePowerLimitRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeConsumptionActivePowerLimitResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetFailsafeConsumptionActivePowerLimit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/SetFailsafeConsumptionActivePowerLimit', + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeConsumptionActivePowerLimitRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeConsumptionActivePowerLimitResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def FailsafeDurationMinimum(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/FailsafeDurationMinimum', + usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeDurationMinimumRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.FailsafeDurationMinimumResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetFailsafeDurationMinimum(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/SetFailsafeDurationMinimum', + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeDurationMinimumRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetFailsafeDurationMinimumResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def StartHeartbeat(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/StartHeartbeat', + usecases_dot_cs_dot_lpc_dot_messages__pb2.StartHeartbeatRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.StartHeartbeatResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def StopHeartbeat(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/StopHeartbeat', + usecases_dot_cs_dot_lpc_dot_messages__pb2.StopHeartbeatRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.StopHeartbeatResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def IsHeartbeatWithinDuration(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/IsHeartbeatWithinDuration', + usecases_dot_cs_dot_lpc_dot_messages__pb2.IsHeartbeatWithinDurationRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.IsHeartbeatWithinDurationResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ConsumptionNominalMax(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/ConsumptionNominalMax', + usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionNominalMaxRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.ConsumptionNominalMaxResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetConsumptionNominalMax(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/cs_lpc.ControllableSystemLPCControl/SetConsumptionNominalMax', + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionNominalMaxRequest.SerializeToString, + usecases_dot_cs_dot_lpc_dot_messages__pb2.SetConsumptionNominalMaxResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) diff --git a/tests/eebus_tests/grpc_server/control_service_server.py b/tests/eebus_tests/grpc_server/control_service_server.py new file mode 100644 index 0000000000..215b24378d --- /dev/null +++ b/tests/eebus_tests/grpc_server/control_service_server.py @@ -0,0 +1,41 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import asyncio +import logging +import os +import pathlib + +import grpc.aio as grpc_aio + +from helpers.import_helpers import insert_dir_to_sys_path + +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") + +import control_service.control_service_pb2_grpc as control_service_pb2_grpc + + +class ControlServiceServer: + """ + This class is a wrapper around the asyncio gRPC server for the Control Service. + """ + + def __init__(self, servicer, port: int | None = None): + self._server = grpc_aio.server() + control_service_pb2_grpc.add_ControlServiceServicer_to_server( + servicer, + self._server + ) + if port is not None: + self._port = self._server.add_insecure_port(f'[::]:{port}') + else: + self._port = self._server.add_insecure_port('[::]:0') + + def get_port(self) -> int: + return self._port + + async def start(self): + await self._server.start() + + async def stop(self): + await self._server.stop(0) \ No newline at end of file diff --git a/tests/eebus_tests/grpc_server/cs_lpc_control_server.py b/tests/eebus_tests/grpc_server/cs_lpc_control_server.py new file mode 100644 index 0000000000..f3861d2cb1 --- /dev/null +++ b/tests/eebus_tests/grpc_server/cs_lpc_control_server.py @@ -0,0 +1,42 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import asyncio +import logging +import os +import pathlib + +import grpc.aio as grpc_aio + +from helpers.import_helpers import insert_dir_to_sys_path + +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") + +import usecases.cs.lpc.service_pb2_grpc as cs_lpc_service_pb2_grpc + + +class CsLpcControlServer: + """ + This class is a wrapper around the asyncio gRPC server for the Controllable System + Limit Power Consumption (LPC) use case. + """ + + def __init__(self, servicer, port: int | None = None): + self._server = grpc_aio.server() + cs_lpc_service_pb2_grpc.add_ControllableSystemLPCControlServicer_to_server( + servicer, + self._server + ) + if port is not None: + self._port = self._server.add_insecure_port(f'[::]:{port}') + else: + self._port = self._server.add_insecure_port('[::]:0') + + def get_port(self) -> int: + return self._port + + async def start(self): + await self._server.start() + + async def stop(self): + await self._server.stop(0) \ No newline at end of file diff --git a/tests/eebus_tests/grpc_servicer/__init__.py b/tests/eebus_tests/grpc_servicer/__init__.py new file mode 100644 index 0000000000..112a431ac4 --- /dev/null +++ b/tests/eebus_tests/grpc_servicer/__init__.py @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest diff --git a/tests/eebus_tests/grpc_servicer/common.py b/tests/eebus_tests/grpc_servicer/common.py new file mode 100644 index 0000000000..ec67710b2d --- /dev/null +++ b/tests/eebus_tests/grpc_servicer/common.py @@ -0,0 +1,29 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +from dataclasses import dataclass +import asyncio +import logging + +@dataclass +class CommandQueues: + """ + Class to hold the queues for the commands + """ + request_queue: asyncio.Queue + response_queue: asyncio.Queue + +async def default_command_func(self, request, context, command): + """ + Default command function to handle the request and response queues + """ + logging.info(f"Command {command} called") + try: + self.command_queues[command].request_queue.put_nowait(request) + except asyncio.QueueFull: + raise asyncio.QueueFull(f"{command} request queue is full, not able to put request") + try: + response = await asyncio.wait_for(self.command_queues[command].response_queue.get(), timeout=30) + except asyncio.TimeoutError: + raise asyncio.TimeoutError(f"{command} response queue is empty, not able to get response") + return response \ No newline at end of file diff --git a/tests/eebus_tests/grpc_servicer/control_service_servicer.py b/tests/eebus_tests/grpc_servicer/control_service_servicer.py new file mode 100644 index 0000000000..5e6ce9cb8f --- /dev/null +++ b/tests/eebus_tests/grpc_servicer/control_service_servicer.py @@ -0,0 +1,91 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os +import sys +import pathlib +import asyncio +import logging + +# Add generated protobuf code to path +current_dir = os.path.dirname(os.path.realpath(__file__)) +generated_dir = os.path.join(current_dir, "..", "grpc_libs", "generated") +sys.path.insert(0, generated_dir) + +import control_service.control_service_pb2_grpc as control_service_pb2_grpc +from .common import CommandQueues, default_command_func + + +class ControlServiceServicer(control_service_pb2_grpc.ControlServiceServicer): + """ + This class implements the asyncio gRPC service for the Control Service. + """ + + def __init__(self): + self._stopped = False + self._commands = [ + "StartService", + "StopService", + "SetConfig", + "StartSetup", + "AddEntity", + "RemoveEntity", + "RegisterRemoteSki", + "AddUseCase", + "SubscribeUseCaseEvents", + ] + self.command_queues = {} + + for command in self._commands: + if command == "SubscribeUseCaseEvents": + self.command_queues[command] = CommandQueues( + request_queue=asyncio.Queue(maxsize=1), + response_queue=asyncio.Queue() + ) + else: + self.command_queues[command] = CommandQueues( + request_queue=asyncio.Queue(maxsize=1), + response_queue=asyncio.Queue(maxsize=1) + ) + + def stop(self): + logging.info("Stop called on ControlServiceServicer") + self._stopped = True + + async def StartService(self, request, context): + return await default_command_func(self, request, context, "StartService") + + async def StopService(self, request, context): + return await default_command_func(self, request, context, "StopService") + + async def SetConfig(self, request, context): + return await default_command_func(self, request, context, "SetConfig") + + async def StartSetup(self, request, context): + return await default_command_func(self, request, context, "StartSetup") + + async def AddEntity(self, request, context): + return await default_command_func(self, request, context, "AddEntity") + + async def RemoveEntity(self, request, context): + return await default_command_func(self, request, context, "RemoveEntity") + + async def RegisterRemoteSki(self, request, context): + return await default_command_func(self, request, context, "RegisterRemoteSki") + + async def AddUseCase(self, request, context): + return await default_command_func(self, request, context, "AddUseCase") + + async def SubscribeUseCaseEvents(self, request, context): + logging.info("SubscribeUseCaseEvents called") + try: + self.command_queues["SubscribeUseCaseEvents"].request_queue.put_nowait(request) + except asyncio.QueueFull: + raise asyncio.QueueFull("SubscribeUseCaseEvents request queue is full, not able to put request") + + while not self._stopped: + try: + res = await asyncio.wait_for(self.command_queues["SubscribeUseCaseEvents"].response_queue.get(), timeout=15) + yield res + except asyncio.TimeoutError: + continue diff --git a/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py b/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py new file mode 100644 index 0000000000..edaa3444b2 --- /dev/null +++ b/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py @@ -0,0 +1,86 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os +import sys +import pathlib +import asyncio +import logging + +# Add generated protobuf code to path +current_dir = os.path.dirname(os.path.realpath(__file__)) +generated_dir = os.path.join(current_dir, "..", "grpc_libs", "generated") +sys.path.insert(0, generated_dir) + +import usecases.cs.lpc.service_pb2_grpc as cs_lpc_service_pb2_grpc +from .common import CommandQueues, default_command_func + + +class CsLpcControlServicer(cs_lpc_service_pb2_grpc.ControllableSystemLPCControlServicer): + """ + This class implements the asyncio gRPC service for the Controllable System + Limit Power Consumption (LPC) use case. + """ + + def __init__(self): + self._commands = [ + "ConsumptionLimit", + "SetConsumptionLimit", + "PendingConsumptionLimit", + "ApproveOrDenyConsumptionLimit", + "FailsafeConsumptionActivePowerLimit", + "SetFailsafeConsumptionActivePowerLimit", + "FailsafeDurationMinimum", + "SetFailsafeDurationMinimum", + "StartHeartbeat", + "StopHeartbeat", + "IsHeartbeatWithinDuration", + "ConsumptionNominalMax", + "SetConsumptionNominalMax" + ] + self.command_queues = {} + + for command in self._commands: + self.command_queues[command] = CommandQueues( + request_queue=asyncio.Queue(maxsize=1), + response_queue=asyncio.Queue(maxsize=1) + ) + + async def ConsumptionLimit(self, request, context): + return await default_command_func(self, request, context, "ConsumptionLimit") + + async def SetConsumptionLimit(self, request, context): + return await default_command_func(self, request, context, "SetConsumptionLimit") + + async def PendingConsumptionLimit(self, request, context): + return await default_command_func(self, request, context, "PendingConsumptionLimit") + + async def ApproveOrDenyConsumptionLimit(self, request, context): + return await default_command_func(self, request, context, "ApproveOrDenyConsumptionLimit") + + async def FailsafeConsumptionActivePowerLimit(self, request, context): + return await default_command_func(self, request, context, "FailsafeConsumptionActivePowerLimit") + + async def SetFailsafeConsumptionActivePowerLimit(self, request, context): + return await default_command_func(self, request, context, "SetFailsafeConsumptionActivePowerLimit") + + async def FailsafeDurationMinimum(self, request, context): + return await default_command_func(self, request, context, "FailsafeDurationMinimum") + + async def SetFailsafeDurationMinimum(self, request, context): + return await default_command_func(self, request, context, "SetFailsafeDurationMinimum") + + async def StartHeartbeat(self, request, context): + return await default_command_func(self, request, context, "StartHeartbeat") + + async def StopHeartbeat(self, request, context): + return await default_command_func(self, request, context, "StopHeartbeat") + + async def IsHeartbeatWithinDuration(self, request, context): + return await default_command_func(self, request, context, "IsHeartbeatWithinDuration") + + async def ConsumptionNominalMax(self, request, context): + return await default_command_func(self, request, context, "ConsumptionNominalMax") + + async def SetConsumptionNominalMax(self, request, context): + return await default_command_func(self, request, context, "SetConsumptionNominalMax") \ No newline at end of file diff --git a/tests/eebus_tests/helpers/__init__.py b/tests/eebus_tests/helpers/__init__.py new file mode 100644 index 0000000000..112a431ac4 --- /dev/null +++ b/tests/eebus_tests/helpers/__init__.py @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest diff --git a/tests/eebus_tests/helpers/async_helpers.py b/tests/eebus_tests/helpers/async_helpers.py new file mode 100644 index 0000000000..f4f2f0e368 --- /dev/null +++ b/tests/eebus_tests/helpers/async_helpers.py @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import asyncio + +async def async_get(q: asyncio.Queue, timeout: float = None): + """ + Asynchronously gets an item from an asyncio.Queue with a timeout. + """ + try: + return await asyncio.wait_for(q.get(), timeout=timeout) + except asyncio.TimeoutError: + raise TimeoutError(f"async_get timed out after {timeout} seconds") \ No newline at end of file diff --git a/tests/eebus_tests/helpers/conversions.py b/tests/eebus_tests/helpers/conversions.py new file mode 100644 index 0000000000..259184bc21 --- /dev/null +++ b/tests/eebus_tests/helpers/conversions.py @@ -0,0 +1,78 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +from .types import LimitsReq, ScheduleReqEntry, ExternalLimits, TotalPowerW +import datetime + +def convert_limits(limits_in: dict) -> LimitsReq: + """ + Converts dict to LimitsReq + """ + if not isinstance(limits_in, dict): + raise TypeError("limits_in is not a dict") + limits = LimitsReq() + if "total_power_W" in limits_in: + total_power_W_in = limits_in["total_power_W"] + if not isinstance(total_power_W_in, dict): + raise TypeError("total_power_W is not a dict") + if not "source" in total_power_W_in or total_power_W_in["source"] is None: + raise ValueError("total_power_W source is not provided") + if not "value" in total_power_W_in or total_power_W_in["value"] is None: + raise ValueError("total_power_W value is not provided") + total_power_W = TotalPowerW( + source=total_power_W_in["source"], + value=float(total_power_W_in["value"]) + ) + limits.total_power_W = total_power_W + if "ac_max_current_A" in limits_in: + limits.ac_max_current_A = limits_in["ac_max_current_A"] + if "ac_min_current_A" in limits_in: + limits.ac_min_current_A = limits_in["ac_min_current_A"] + if "ac_max_phase_count" in limits_in: + limits.ac_max_phase_count = limits_in["ac_max_phase_count"] + if "ac_min_phase_count" in limits_in: + limits.ac_min_phase_count = limits_in["ac_min_phase_count"] + if "ac_supports_changing_phases_during_charging" in limits_in: + limits.ac_supports_changing_phases_during_charging = limits_in["ac_supports_changing_phases_during_charging"] + if "ac_number_of_active_phases" in limits_in: + limits.ac_number_of_active_phases = limits_in["ac_number_of_active_phases"] + return limits + +def convert_schedule_req_entry_list(schedule_in: list) -> list[ScheduleReqEntry]: + """ + Converts list of dicts to list of ScheduleReqEntry + """ + if not isinstance(schedule_in, list): + raise TypeError("schedule_in is not a list") + schedule = [] + for schedule_entry_in in schedule_in: + schedule_entry_out = ScheduleReqEntry( + timestamp=datetime.datetime.fromisoformat(schedule_entry_in["timestamp"]), + limits_to_root=LimitsReq(), + limits_to_leaves=LimitsReq(), + conversion_efficiency=None, + prive_per_kwh=None + ) + if "limits_to_root" in schedule_entry_in and schedule_entry_in["limits_to_root"] is not None: + schedule_entry_out.limits_to_root = convert_limits(schedule_entry_in["limits_to_root"]) + if "limits_to_leaves" in schedule_entry_in and schedule_entry_in["limits_to_leaves"] is not None: + schedule_entry_out.limits_to_leaves = convert_limits(schedule_entry_in["limits_to_leaves"]) + if "conversion_efficiency" in schedule_entry_in and schedule_entry_in["conversion_efficiency"] is not None: + raise NotImplementedError("conversion_efficiency is not implemented") + if "prive_per_kwh" in schedule_entry_in and schedule_entry_in["prive_per_kwh"] is not None: + raise NotImplementedError("prive_per_kwh is not implemented") + schedule.append(schedule_entry_out) + return schedule + +def convert_external_limits(args: dict) -> ExternalLimits: + """ + Converts dict to ExternalLimits + """ + limits: ExternalLimits = ExternalLimits() + if not isinstance(args, dict) or "value" not in args or args["value"] is None: + raise ValueError("No value provided") + if "schedule_import" in args["value"] and args["value"]["schedule_import"] is not None: + limits.schedule_import = convert_schedule_req_entry_list(args["value"]["schedule_import"]) + if "schedule_export" in args["value"] and args["value"]["schedule_export"] is not None: + limits.schedule_export = convert_schedule_req_entry_list(args["value"]["schedule_export"]) + return limits diff --git a/tests/eebus_tests/helpers/import_helpers.py b/tests/eebus_tests/helpers/import_helpers.py new file mode 100644 index 0000000000..2521e570f2 --- /dev/null +++ b/tests/eebus_tests/helpers/import_helpers.py @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os,sys +import pathlib + +def insert_dir_to_sys_path(directory: pathlib.Path): + """ + This helper allows to insert a directory to the sys.path. + """ + if not os.path.exists(directory): + raise FileNotFoundError(f"Directory {directory} does not exist") + directory = directory.resolve().as_posix() + if directory in sys.path: + return + sys.path.insert(0, directory) diff --git a/tests/eebus_tests/helpers/queue_helpers.py b/tests/eebus_tests/helpers/queue_helpers.py new file mode 100644 index 0000000000..13f3166d69 --- /dev/null +++ b/tests/eebus_tests/helpers/queue_helpers.py @@ -0,0 +1,21 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import queue +import time + +def wait_for_queue_empty(queue: queue.Queue, timeout: int): + """ + Wait for the queue to be empty. + + It waits for the queue to be empty for a given timeout. + If the queue is not empty after the timeout, it raises a TimeoutError. + """ + if timeout <= 0: + raise ValueError("Timeout must be greater than 0") + time_start = time.time() + while not queue.empty(): + time_now = time.time() + if time_now - time_start > timeout: + raise TimeoutError("Queue is not empty after timeout") + time.sleep(0.1) diff --git a/tests/eebus_tests/helpers/types.py b/tests/eebus_tests/helpers/types.py new file mode 100644 index 0000000000..ef5343f134 --- /dev/null +++ b/tests/eebus_tests/helpers/types.py @@ -0,0 +1,57 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +from dataclasses import dataclass, field +import datetime + +@dataclass +class PricePerKWh: + """ + EVerest type + """ + timestamp: datetime.datetime + value: float + currency: str + +@dataclass +class TotalPowerW: + """ + EVerest type + """ + source: str + value: float + +@dataclass +class LimitsReq: + """ + EVerest type + """ + total_power_W: TotalPowerW | None = None + ac_max_current_A: float | None = None + ac_min_current_A: float | None = None + ac_max_phase_count: int | None = None + ac_min_phase_count: int | None = None + ac_supports_changing_phases_during_charging: bool | None = None + ac_number_of_active_phases: int | None = None + +@dataclass +class ScheduleReqEntry: + """ + EVerest type + + timestamp won't be compared, since it is not possible to + assume the exact timestamp that is used by the EEBUS module + """ + timestamp: datetime.datetime = field(compare=False) + limits_to_root: LimitsReq + limits_to_leaves: LimitsReq + conversion_efficiency: float | None = None + prive_per_kwh: PricePerKWh | None = None + +@dataclass +class ExternalLimits: + """ + EVerest type + """ + schedule_import: list[ScheduleReqEntry] | None = None + schedule_export: list[ScheduleReqEntry] | None = None diff --git a/tests/eebus_tests/test_data/__init__.py b/tests/eebus_tests/test_data/__init__.py new file mode 100644 index 0000000000..112a431ac4 --- /dev/null +++ b/tests/eebus_tests/test_data/__init__.py @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest diff --git a/tests/eebus_tests/test_data/test_data.py b/tests/eebus_tests/test_data/test_data.py new file mode 100644 index 0000000000..4903ce5575 --- /dev/null +++ b/tests/eebus_tests/test_data/test_data.py @@ -0,0 +1,27 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os, pathlib + +from helpers.types import ExternalLimits + +from helpers.import_helpers import insert_dir_to_sys_path +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 + +class TestData: + """ + Abstract class for test data. + + - get_load_limit: Should return the load limit that is sent to the EEBUS module + - get_expected_external_limits: Should return the expected external limits + that are sent to the probe module by the EEBUS module + - run_additional_assertions: Is called in test case to run additional assertions + on the limits that are sent to the probe module by the EEBUS module + """ + def get_load_limit(self) -> common_types_pb2.LoadLimit: + raise NotImplementedError("get_load_limit is not implemented") + def get_expected_external_limits(self) -> ExternalLimits: + raise NotImplementedError("get_expected_external_limits is not implemented") + def run_additional_assertions(self, limits: ExternalLimits, expected_limits: ExternalLimits): + raise NotImplementedError("run_additional_assertions is not implemented") diff --git a/tests/eebus_tests/test_data/test_data_active_load_limit.py b/tests/eebus_tests/test_data/test_data_active_load_limit.py new file mode 100644 index 0000000000..a90ea5572a --- /dev/null +++ b/tests/eebus_tests/test_data/test_data_active_load_limit.py @@ -0,0 +1,55 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os, pathlib +import datetime + +from .test_data import TestData +from helpers.types import ExternalLimits, ScheduleReqEntry, LimitsReq, TotalPowerW + +from helpers.import_helpers import insert_dir_to_sys_path +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 + + +class TestDataActiveLoadLimit(TestData): + """ + In this scenario, the load limit is active and has no duration. + + This means an external limits with one entry is expected: + - The entry to activate the limit + """ + def get_load_limit(self) -> common_types_pb2.LoadLimit: + return common_types_pb2.LoadLimit( + duration_nanoseconds=0, + is_changeable=True, + is_active=True, + value=4200, + delete_duration=False, + ) + + def get_expected_external_limits(self) -> ExternalLimits: + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq( + total_power_W=TotalPowerW( + source="EEBUS LPC", + value=4200.0, + ), + ), + limits_to_leaves=LimitsReq( + total_power_W=TotalPowerW( + source="EEBUS LPC", + value=4200.0, + ), + ), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + def run_additional_assertions(self, limits: ExternalLimits): + assert True diff --git a/tests/eebus_tests/test_data/test_data_active_load_limit_with_duration.py b/tests/eebus_tests/test_data/test_data_active_load_limit_with_duration.py new file mode 100644 index 0000000000..6e495bc5c9 --- /dev/null +++ b/tests/eebus_tests/test_data/test_data_active_load_limit_with_duration.py @@ -0,0 +1,72 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os, pathlib +import datetime + +from .test_data import TestData +from helpers.types import ExternalLimits, ScheduleReqEntry, LimitsReq, TotalPowerW + +from helpers.import_helpers import insert_dir_to_sys_path +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 + +def assert_time_delta(time1: datetime.datetime, time2: datetime.datetime, expected_delta: datetime.timedelta): + delta = time2 - time1 + assert int(delta.total_seconds()) == int(expected_delta.total_seconds()) + +class TestDataActiveLoadLimitWithDuration(TestData): + """ + In this scenario, the load limit is active and has a duration. + + This means an external limits with to entries is expected: + - The first entry to activate the limit + - The second entry to deactivate the limit + + The difference between the two entries should be 2 hours. + """ + def get_load_limit(self) -> common_types_pb2.LoadLimit: + return common_types_pb2.LoadLimit( + duration_nanoseconds=int(datetime.timedelta(hours=2).total_seconds()) * 1000 * 1000 * 1000, # 2 hours + is_changeable=True, + is_active=True, + value=4200, + delete_duration=False, + ) + + def get_expected_external_limits(self) -> ExternalLimits: + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq( + total_power_W=TotalPowerW( + source='EEBUS LPC', + value=4200.0, + ), + ), + limits_to_leaves=LimitsReq( + total_power_W=TotalPowerW( + source='EEBUS LPC', + value=4200.0, + ), + ), + conversion_efficiency=None, + prive_per_kwh=None + ), + ScheduleReqEntry( + timestamp=datetime.datetime.now() + datetime.timedelta(seconds=2 * 60 * 60), + limits_to_root=LimitsReq(), + limits_to_leaves=LimitsReq(), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + def run_additional_assertions(self, limits: ExternalLimits): + assert_time_delta( + limits.schedule_import[0].timestamp, + limits.schedule_import[1].timestamp, + datetime.timedelta(hours=2) + ) diff --git a/tests/eebus_tests/test_data/test_data_failsafe.py b/tests/eebus_tests/test_data/test_data_failsafe.py new file mode 100644 index 0000000000..ba57e2e592 --- /dev/null +++ b/tests/eebus_tests/test_data/test_data_failsafe.py @@ -0,0 +1,83 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os, pathlib +import datetime + +from .test_data import TestData +from helpers.types import ExternalLimits, ScheduleReqEntry, LimitsReq, TotalPowerW + +from helpers.import_helpers import insert_dir_to_sys_path +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 + +class TestDataFailsafe(TestData): + """ + In this scenario, the module enters failsafe state due to missing heartbeat. + It then transitions to unlimited autonomous after failsafe duration expires. + """ + def get_load_limit(self) -> common_types_pb2.LoadLimit: + # This is not directly used for failsafe, but required by the test setup + return common_types_pb2.LoadLimit( + duration_nanoseconds=0, + is_changeable=True, + is_active=False, + value=4200, + delete_duration=False, + ) + + def get_expected_external_limits(self) -> ExternalLimits: + # The initial limit is inactive, then failsafe limit is applied, then no limit + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq(), + limits_to_leaves=LimitsReq(), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + + def get_expected_failsafe_limits(self, failsafe_control_limit: int) -> ExternalLimits: + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq( + total_power_W=TotalPowerW( + source="EEBUS LPC", + value=float(failsafe_control_limit), + ), + ), + limits_to_leaves=LimitsReq( + total_power_W=TotalPowerW( + source="EEBUS LPC", + value=float(failsafe_control_limit), + ), + ), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + + def get_expected_unlimited_autonomous_limits(self) -> ExternalLimits: + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq(), + limits_to_leaves=LimitsReq(), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + + def run_additional_assertions(self, limits: ExternalLimits): + assert True diff --git a/tests/eebus_tests/test_data/test_data_heartbeat.py b/tests/eebus_tests/test_data/test_data_heartbeat.py new file mode 100644 index 0000000000..2b7247d4d5 --- /dev/null +++ b/tests/eebus_tests/test_data/test_data_heartbeat.py @@ -0,0 +1,43 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os, pathlib +import datetime + +from .test_data import TestData +from helpers.types import ExternalLimits, ScheduleReqEntry, LimitsReq, TotalPowerW + +from helpers.import_helpers import insert_dir_to_sys_path +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 + +class TestDataHeartbeat(TestData): + """ + In this scenario, the module receives a heartbeat and transitions to UnlimitedControlled. + """ + def get_load_limit(self) -> common_types_pb2.LoadLimit: + # This is not directly used for heartbeat, but required by the test setup + return common_types_pb2.LoadLimit( + duration_nanoseconds=0, + is_changeable=True, + is_active=False, + value=4200, + delete_duration=False, + ) + + def get_expected_external_limits(self) -> ExternalLimits: + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq(), + limits_to_leaves=LimitsReq(), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + + def run_additional_assertions(self, limits: ExternalLimits): + assert True diff --git a/tests/eebus_tests/test_data/test_data_not_active_load_limit.py b/tests/eebus_tests/test_data/test_data_not_active_load_limit.py new file mode 100644 index 0000000000..4943069201 --- /dev/null +++ b/tests/eebus_tests/test_data/test_data_not_active_load_limit.py @@ -0,0 +1,44 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright Pionix GmbH and Contributors to EVerest + +import os, pathlib +import datetime + +from .test_data import TestData +from helpers.types import ExternalLimits, ScheduleReqEntry, LimitsReq + +from helpers.import_helpers import insert_dir_to_sys_path +insert_dir_to_sys_path(pathlib.Path(os.path.dirname(os.path.realpath(__file__))) / "../grpc_libs/generated") +import common_types.types_pb2 as common_types_pb2 + +class TestDataNotActiveLoadLimit(TestData): + """ + In this scenario, the load limit is not active and has no duration. + + This means an external limits with one entry is expected: + - The entry to deactivate the limit + """ + def get_load_limit(self) -> common_types_pb2.LoadLimit: + return common_types_pb2.LoadLimit( + duration_nanoseconds=0, + is_changeable=True, + is_active=False, + value=4200, + delete_duration=False, + ) + + def get_expected_external_limits(self) -> ExternalLimits: + return ExternalLimits( + schedule_import=[ + ScheduleReqEntry( + timestamp=datetime.datetime.now(), + limits_to_root=LimitsReq(), + limits_to_leaves=LimitsReq(), + conversion_efficiency=None, + prive_per_kwh=None + ) + ], + schedule_export=[], + ) + def run_additional_assertions(self, limits: ExternalLimits): + assert True diff --git a/tests/everest-core_tests/config/config-test-eebus-module-001.yaml b/tests/everest-core_tests/config/config-test-eebus-module-001.yaml new file mode 100644 index 0000000000..31deb079b0 --- /dev/null +++ b/tests/everest-core_tests/config/config-test-eebus-module-001.yaml @@ -0,0 +1,18 @@ +active_modules: + eebus: + module: EEBUS + connections: + eebus_energy_sink: + - module_id: probe + implementation_id: eebus_energy_sink + config_module: + manage_eebus_grpc_api_binary: false + vendor_code: "EVerest" + device_brand: "EVerest" + device_model: "SIL" + serial_number: "123456789" + eebus_service_port: 4715 + grpc_port: 50051 + eebus_ems_ski: "this-is-a-ski-42" + probe: + module: ProbeModule diff --git a/tests/pytest.ini b/tests/pytest.ini index 474ac83ef6..6979fa03eb 100644 --- a/tests/pytest.ini +++ b/tests/pytest.ini @@ -7,3 +7,6 @@ markers = everest_core_config: marks tests using a specific config (deselect with '-m "not everest_core_config"') everest_config_adaptions: modify config for a specific testcase probe_module: Enable the use of the probe module in this test. + eebus_certificate_path: certificate used for eebus grpc api + eebus_private_key_path: private key used for eebus grpc api + eebus_rpc_port: port used for eebus grpc api