From 18a964a798125b41d95d0c080988cb185afab2f5 Mon Sep 17 00:00:00 2001 From: Andreas Heinrich Date: Wed, 5 Mar 2025 19:06:17 +0100 Subject: [PATCH 1/4] feat(EEBus): Implement EEBus LPC Use Case This is the first implementation of EEBus and the LPC use case. The EEBUS module requires an energy sink to limit the energy flow request going to the energy manager. Signed-off-by: Andreas Heinrich Signed-off-by: Martin Litre --- .ci/build-kit/docker/Dockerfile | 83 + .ci/build-kit/scripts/compile.sh | 5 +- .../scripts/create_integration_image.sh | 2 +- .../scripts/create_ocpp_tests_image.sh | 4 +- .ci/e2e/scripts/run_integration_tests.sh | 3 +- .ci/e2e/scripts/run_ocpp_tests.sh | 2 +- .github/workflows/build_and_test.yaml | 3 +- CMakeLists.txt | 7 +- cmake/external/eebus-grpc.cmake | 132 + config/CMakeLists.txt | 2 +- config/config-eebus.yaml | 204 + dependencies.yaml | 20 + module-dependencies.cmake | 17 + modules/EnergyManagement/CMakeLists.txt | 1 + modules/EnergyManagement/EEBUS/CMakeLists.txt | 61 + .../EEBUS/ConfigValidator.cpp | 198 + modules/EnergyManagement/EEBUS/EEBUS.cpp | 102 + modules/EnergyManagement/EEBUS/EEBUS.hpp | 89 + .../EnergyManagement/EEBUS/EebusCallbacks.cpp | 11 + .../EEBUS/EebusConnectionHandler.cpp | 140 + .../EEBUS/LpcUseCaseHandler.cpp | 380 ++ .../EEBUS/UseCaseEventReader.cpp | 41 + ...us-generate-and-install-certificates.cmake | 16 + modules/EnergyManagement/EEBUS/doc.rst | 328 + .../EEBUS/grpc_libs/CMakeLists.txt | 22 + .../EEBUS/grpc_libs/cmake/add-libraries.cmake | 101 + .../cmake/generate-cpp-from-protobuf.cmake | 56 + .../EEBUS/grpc_libs/cmake/sanity-checks.cmake | 58 + .../common_types/types.grpc-ext.pb.cc | 9 + .../common_types/types.grpc-ext.pb.h | 10 + .../generated/common_types/types.grpc.pb.cc | 25 + .../generated/common_types/types.grpc.pb.h | 39 + .../generated/common_types/types.pb.cc | 729 +++ .../generated/common_types/types.pb.h | 709 +++ .../control_service.grpc-ext.pb.cc | 185 + .../control_service.grpc-ext.pb.h | 51 + .../control_service.grpc.pb.cc | 415 ++ .../control_service/control_service.grpc.pb.h | 1531 +++++ .../control_service/control_service.pb.cc | 97 + .../control_service/control_service.pb.h | 87 + .../control_service/messages.grpc-ext.pb.cc | 9 + .../control_service/messages.grpc-ext.pb.h | 12 + .../control_service/messages.grpc.pb.cc | 25 + .../control_service/messages.grpc.pb.h | 39 + .../generated/control_service/messages.pb.cc | 3263 ++++++++++ .../generated/control_service/messages.pb.h | 3530 +++++++++++ .../control_service/types.grpc-ext.pb.cc | 9 + .../control_service/types.grpc-ext.pb.h | 10 + .../control_service/types.grpc.pb.cc | 25 + .../generated/control_service/types.grpc.pb.h | 39 + .../generated/control_service/types.pb.cc | 1694 +++++ .../generated/control_service/types.pb.h | 2079 +++++++ .../usecases/cs/lpc/messages.grpc-ext.pb.cc | 9 + .../usecases/cs/lpc/messages.grpc-ext.pb.h | 11 + .../usecases/cs/lpc/messages.grpc.pb.cc | 25 + .../usecases/cs/lpc/messages.grpc.pb.h | 39 + .../generated/usecases/cs/lpc/messages.pb.cc | 5425 +++++++++++++++++ .../generated/usecases/cs/lpc/messages.pb.h | 5320 ++++++++++++++++ .../usecases/cs/lpc/service.grpc-ext.pb.cc | 295 + .../usecases/cs/lpc/service.grpc-ext.pb.h | 76 + .../usecases/cs/lpc/service.grpc.pb.cc | 590 ++ .../usecases/cs/lpc/service.grpc.pb.h | 2130 +++++++ .../generated/usecases/cs/lpc/service.pb.cc | 113 + .../generated/usecases/cs/lpc/service.pb.h | 87 + modules/EnergyManagement/EEBUS/helper.cpp | 57 + .../EEBUS/include/ConfigValidator.hpp | 61 + .../EEBUS/include/EebusCallbacks.hpp | 15 + .../EEBUS/include/EebusConnectionHandler.hpp | 47 + .../EEBUS/include/LpcUseCaseHandler.hpp | 86 + .../EEBUS/include/UseCaseEventReader.hpp | 29 + .../EnergyManagement/EEBUS/include/helper.hpp | 22 + .../EnergyManagement/EEBUS/main/emptyImpl.cpp | 16 + .../EnergyManagement/EEBUS/main/emptyImpl.hpp | 60 + modules/EnergyManagement/EEBUS/manifest.yaml | 71 + tests/CMakeLists.txt | 1 + tests/eebus_tests/CMakeLists.txt | 4 + tests/eebus_tests/eebus_tests.py | 606 ++ tests/eebus_tests/fixtures/__init__.py | 2 + .../eebus_tests/fixtures/eebus_module_test.py | 74 + .../fixtures/grpc_testing_server.py | 50 + tests/eebus_tests/grpc_libs/CMakeLists.txt | 53 + .../generated/common_types/types_pb2.py | 39 + .../generated/common_types/types_pb2.pyi | 27 + .../generated/common_types/types_pb2_grpc.py | 24 + .../control_service/control_service_pb2.py | 38 + .../control_service/control_service_pb2.pyi | 5 + .../control_service_pb2_grpc.py | 451 ++ .../generated/control_service/messages_pb2.py | 57 + .../control_service/messages_pb2.pyi | 91 + .../control_service/messages_pb2_grpc.py | 24 + .../generated/control_service/types_pb2.py | 61 + .../generated/control_service/types_pb2.pyi | 326 + .../control_service/types_pb2_grpc.py | 24 + .../generated/usecases/cs/lpc/messages_pb2.py | 92 + .../usecases/cs/lpc/messages_pb2.pyi | 153 + .../usecases/cs/lpc/messages_pb2_grpc.py | 24 + .../generated/usecases/cs/lpc/service_pb2.py | 38 + .../generated/usecases/cs/lpc/service_pb2.pyi | 5 + .../usecases/cs/lpc/service_pb2_grpc.py | 613 ++ .../grpc_server/control_service_server.py | 41 + .../grpc_server/cs_lpc_control_server.py | 42 + tests/eebus_tests/grpc_servicer/__init__.py | 2 + tests/eebus_tests/grpc_servicer/common.py | 29 + .../grpc_servicer/control_service_servicer.py | 91 + .../grpc_servicer/cs_lpc_control_servicer.py | 86 + tests/eebus_tests/helpers/__init__.py | 2 + tests/eebus_tests/helpers/async_helpers.py | 13 + tests/eebus_tests/helpers/conversions.py | 78 + tests/eebus_tests/helpers/import_helpers.py | 16 + tests/eebus_tests/helpers/queue_helpers.py | 21 + tests/eebus_tests/helpers/types.py | 57 + tests/eebus_tests/test_data/__init__.py | 2 + tests/eebus_tests/test_data/test_data.py | 27 + .../test_data/test_data_active_load_limit.py | 55 + ...st_data_active_load_limit_with_duration.py | 72 + .../test_data/test_data_failsafe.py | 83 + .../test_data/test_data_heartbeat.py | 43 + .../test_data_not_active_load_limit.py | 44 + .../config/config-test-eebus-module-001.yaml | 18 + tests/pytest.ini | 3 + 120 files changed, 34991 insertions(+), 9 deletions(-) create mode 100644 cmake/external/eebus-grpc.cmake create mode 100644 config/config-eebus.yaml create mode 100644 modules/EnergyManagement/EEBUS/CMakeLists.txt create mode 100644 modules/EnergyManagement/EEBUS/ConfigValidator.cpp create mode 100644 modules/EnergyManagement/EEBUS/EEBUS.cpp create mode 100644 modules/EnergyManagement/EEBUS/EEBUS.hpp create mode 100644 modules/EnergyManagement/EEBUS/EebusCallbacks.cpp create mode 100644 modules/EnergyManagement/EEBUS/EebusConnectionHandler.cpp create mode 100644 modules/EnergyManagement/EEBUS/LpcUseCaseHandler.cpp create mode 100644 modules/EnergyManagement/EEBUS/UseCaseEventReader.cpp create mode 100644 modules/EnergyManagement/EEBUS/cmake/eebus-generate-and-install-certificates.cmake create mode 100644 modules/EnergyManagement/EEBUS/doc.rst create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/CMakeLists.txt create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/cmake/add-libraries.cmake create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/cmake/generate-cpp-from-protobuf.cmake create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/cmake/sanity-checks.cmake create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc-ext.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.grpc.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/common_types/types.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc-ext.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.grpc.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/control_service.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc-ext.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.grpc.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/messages.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc-ext.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.grpc.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/control_service/types.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc-ext.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.grpc.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/messages.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc-ext.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.grpc.pb.h create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.cc create mode 100644 modules/EnergyManagement/EEBUS/grpc_libs/generated/usecases/cs/lpc/service.pb.h create mode 100644 modules/EnergyManagement/EEBUS/helper.cpp create mode 100644 modules/EnergyManagement/EEBUS/include/ConfigValidator.hpp create mode 100644 modules/EnergyManagement/EEBUS/include/EebusCallbacks.hpp create mode 100644 modules/EnergyManagement/EEBUS/include/EebusConnectionHandler.hpp create mode 100644 modules/EnergyManagement/EEBUS/include/LpcUseCaseHandler.hpp create mode 100644 modules/EnergyManagement/EEBUS/include/UseCaseEventReader.hpp create mode 100644 modules/EnergyManagement/EEBUS/include/helper.hpp create mode 100644 modules/EnergyManagement/EEBUS/main/emptyImpl.cpp create mode 100644 modules/EnergyManagement/EEBUS/main/emptyImpl.hpp create mode 100644 modules/EnergyManagement/EEBUS/manifest.yaml create mode 100644 tests/eebus_tests/CMakeLists.txt create mode 100644 tests/eebus_tests/eebus_tests.py create mode 100644 tests/eebus_tests/fixtures/__init__.py create mode 100644 tests/eebus_tests/fixtures/eebus_module_test.py create mode 100644 tests/eebus_tests/fixtures/grpc_testing_server.py create mode 100644 tests/eebus_tests/grpc_libs/CMakeLists.txt create mode 100644 tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.py create mode 100644 tests/eebus_tests/grpc_libs/generated/common_types/types_pb2.pyi create mode 100644 tests/eebus_tests/grpc_libs/generated/common_types/types_pb2_grpc.py create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.py create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2.pyi create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/control_service_pb2_grpc.py create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.py create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2.pyi create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/messages_pb2_grpc.py create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/types_pb2.py create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/types_pb2.pyi create mode 100644 tests/eebus_tests/grpc_libs/generated/control_service/types_pb2_grpc.py create mode 100644 tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.py create mode 100644 tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2.pyi create mode 100644 tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/messages_pb2_grpc.py create mode 100644 tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.py create mode 100644 tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2.pyi create mode 100644 tests/eebus_tests/grpc_libs/generated/usecases/cs/lpc/service_pb2_grpc.py create mode 100644 tests/eebus_tests/grpc_server/control_service_server.py create mode 100644 tests/eebus_tests/grpc_server/cs_lpc_control_server.py create mode 100644 tests/eebus_tests/grpc_servicer/__init__.py create mode 100644 tests/eebus_tests/grpc_servicer/common.py create mode 100644 tests/eebus_tests/grpc_servicer/control_service_servicer.py create mode 100644 tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py create mode 100644 tests/eebus_tests/helpers/__init__.py create mode 100644 tests/eebus_tests/helpers/async_helpers.py create mode 100644 tests/eebus_tests/helpers/conversions.py create mode 100644 tests/eebus_tests/helpers/import_helpers.py create mode 100644 tests/eebus_tests/helpers/queue_helpers.py create mode 100644 tests/eebus_tests/helpers/types.py create mode 100644 tests/eebus_tests/test_data/__init__.py create mode 100644 tests/eebus_tests/test_data/test_data.py create mode 100644 tests/eebus_tests/test_data/test_data_active_load_limit.py create mode 100644 tests/eebus_tests/test_data/test_data_active_load_limit_with_duration.py create mode 100644 tests/eebus_tests/test_data/test_data_failsafe.py create mode 100644 tests/eebus_tests/test_data/test_data_heartbeat.py create mode 100644 tests/eebus_tests/test_data/test_data_not_active_load_limit.py create mode 100644 tests/everest-core_tests/config/config-test-eebus-module-001.yaml 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 d3e29be2e8..97345102d0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 tmp/eebus ) 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) @@ -129,6 +130,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() if(EVEREST_DEPENDENCY_ENABLED_SDBUS_CPP AND NOT TARGET SDBusCpp::sdbus-c++) 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 c05d1dff86..c8dd1de286 100644 --- a/dependencies.yaml +++ b/dependencies.yaml @@ -116,3 +116,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 f720a2ad9e..321af736fa 100644 --- a/module-dependencies.cmake +++ b/module-dependencies.cmake @@ -66,3 +66,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 a0561824fd..d5060308ec 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -36,3 +36,4 @@ if(IS_PYTHON_VENV_ACTIVE) endif() 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 From 77b183235520deb0b208b2b66d0c57d62fe81c39 Mon Sep 17 00:00:00 2001 From: Martin Litre Date: Mon, 17 Nov 2025 17:29:54 +0100 Subject: [PATCH 2/4] update everest-cmake Signed-off-by: Martin Litre --- CMakeLists.txt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 97345102d0..b1abcc352c 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 tmp/eebus + GIT_TAG v0.6.0 ) FetchContent_MakeAvailable(everest-cmake) set(everest-cmake_DIR "${everest-cmake_SOURCE_DIR}") From a106b7c3605070cfa23d6a102aee725edd02d9d9 Mon Sep 17 00:00:00 2001 From: Martin Litre Date: Mon, 8 Dec 2025 18:15:04 +0100 Subject: [PATCH 3/4] Apply suggestions from code review Co-authored-by: Andreas Heinrich Signed-off-by: Martin Litre --- modules/EnergyManagement/EEBUS/manifest.yaml | 12 ++++++------ tests/eebus_tests/fixtures/grpc_testing_server.py | 2 +- .../grpc_server/control_service_server.py | 2 +- .../eebus_tests/grpc_server/cs_lpc_control_server.py | 2 +- tests/eebus_tests/grpc_servicer/common.py | 2 +- .../grpc_servicer/cs_lpc_control_servicer.py | 2 +- tests/eebus_tests/helpers/async_helpers.py | 2 +- 7 files changed, 12 insertions(+), 12 deletions(-) diff --git a/modules/EnergyManagement/EEBUS/manifest.yaml b/modules/EnergyManagement/EEBUS/manifest.yaml index 1c1aadcad3..fb6345ad0d 100644 --- a/modules/EnergyManagement/EEBUS/manifest.yaml +++ b/modules/EnergyManagement/EEBUS/manifest.yaml @@ -9,7 +9,7 @@ config: 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. + 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, required/used when manage_eebus_grpc_api_binary=true type: integer default: 50051 eebus_ems_ski: @@ -17,17 +17,17 @@ config: 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. + 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, required/used when manage_eebus_grpc_api_binary=true 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. + 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, required/used when manage_eebus_grpc_api_binary=true 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. + description: Path to the eebus grpc api binary. If relative will be prefixed with everest prefix + libexec. Otherwise absolute file path is used, required/used when manage_eebus_grpc_api_binary=true type: string required: false default: eebus_grpc_api @@ -47,11 +47,11 @@ config: description: Serial number for the configuration of the control service type: string required: true - failsafe_control_limit: + failsafe_control_limit_W: 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: + max_nominal_power_W: description: Maximum nominal power of the charging station. This is the max power the CS can consume. type: integer default: 32000 diff --git a/tests/eebus_tests/fixtures/grpc_testing_server.py b/tests/eebus_tests/fixtures/grpc_testing_server.py index 0f7c1fb858..17e2961009 100644 --- a/tests/eebus_tests/fixtures/grpc_testing_server.py +++ b/tests/eebus_tests/fixtures/grpc_testing_server.py @@ -47,4 +47,4 @@ async def cs_lpc_control_server(cs_lpc_control_servicer): 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 + await server.stop() diff --git a/tests/eebus_tests/grpc_server/control_service_server.py b/tests/eebus_tests/grpc_server/control_service_server.py index 215b24378d..93a63dec80 100644 --- a/tests/eebus_tests/grpc_server/control_service_server.py +++ b/tests/eebus_tests/grpc_server/control_service_server.py @@ -38,4 +38,4 @@ async def start(self): await self._server.start() async def stop(self): - await self._server.stop(0) \ No newline at end of file + await self._server.stop(0) diff --git a/tests/eebus_tests/grpc_server/cs_lpc_control_server.py b/tests/eebus_tests/grpc_server/cs_lpc_control_server.py index f3861d2cb1..2b1e8dd143 100644 --- a/tests/eebus_tests/grpc_server/cs_lpc_control_server.py +++ b/tests/eebus_tests/grpc_server/cs_lpc_control_server.py @@ -39,4 +39,4 @@ async def start(self): await self._server.start() async def stop(self): - await self._server.stop(0) \ No newline at end of file + await self._server.stop(0) diff --git a/tests/eebus_tests/grpc_servicer/common.py b/tests/eebus_tests/grpc_servicer/common.py index ec67710b2d..294d358196 100644 --- a/tests/eebus_tests/grpc_servicer/common.py +++ b/tests/eebus_tests/grpc_servicer/common.py @@ -26,4 +26,4 @@ async def default_command_func(self, request, context, command): 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 + return response diff --git a/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py b/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py index edaa3444b2..51ac3a0329 100644 --- a/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py +++ b/tests/eebus_tests/grpc_servicer/cs_lpc_control_servicer.py @@ -83,4 +83,4 @@ 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 + return await default_command_func(self, request, context, "SetConsumptionNominalMax") diff --git a/tests/eebus_tests/helpers/async_helpers.py b/tests/eebus_tests/helpers/async_helpers.py index f4f2f0e368..52eb8bd5d8 100644 --- a/tests/eebus_tests/helpers/async_helpers.py +++ b/tests/eebus_tests/helpers/async_helpers.py @@ -10,4 +10,4 @@ async def async_get(q: asyncio.Queue, timeout: float = None): 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 + raise TimeoutError(f"async_get timed out after {timeout} seconds") From d1574fe7ba616004ed3881d07830bcafd183d6fd Mon Sep 17 00:00:00 2001 From: Martin Litre Date: Mon, 8 Dec 2025 18:35:35 +0100 Subject: [PATCH 4/4] apply some PR comments + rebase Signed-off-by: Martin Litre --- .ci/build-kit/docker/Dockerfile | 17 ++++------------- .../scripts/create_ocpp_tests_image.sh | 4 ++-- .ci/e2e/scripts/run_integration_tests.sh | 2 +- .ci/e2e/scripts/run_ocpp_tests.sh | 2 +- CMakeLists.txt | 2 +- .../EnergyManagement/EEBUS/ConfigValidator.cpp | 8 ++++---- modules/EnergyManagement/EEBUS/EEBUS.hpp | 4 ++-- 7 files changed, 15 insertions(+), 24 deletions(-) diff --git a/.ci/build-kit/docker/Dockerfile b/.ci/build-kit/docker/Dockerfile index 741de21344..2879fb5f29 100644 --- a/.ci/build-kit/docker/Dockerfile +++ b/.ci/build-kit/docker/Dockerfile @@ -11,9 +11,6 @@ FROM ghcr.io/everest/everest-ci/build-kit-base:${BASE_IMAGE_TAG} # && git checkout ${EVEREST_CMAKE_VERSION} \ # && rm -r .git -# 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} \ @@ -22,6 +19,10 @@ RUN rm -rf ${EVEREST_CMAKE_PATH} \ && git checkout ${EVEREST_CMAKE_VERSION} \ && rm -r .git +# 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 + 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 \ @@ -86,13 +87,3 @@ RUN python3.13 -m pip install --break-system-packages \ 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/create_ocpp_tests_image.sh b/.ci/build-kit/scripts/create_ocpp_tests_image.sh index e823a77ce3..db2f25d44e 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 -python3 -m pip install --break-system-packages \ +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 -python3 -m pip install --break-system-packages -r tests/ocpp_tests/requirements.txt +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 97314fdbf7..cae97a4795 100755 --- a/.ci/e2e/scripts/run_integration_tests.sh +++ b/.ci/e2e/scripts/run_integration_tests.sh @@ -1,7 +1,7 @@ #!/bin/sh cd tests -python3 -m pytest \ +pytest \ -rA \ --junitxml="$EXT_MOUNT/result.xml" \ --html="$EXT_MOUNT/report.html" \ diff --git a/.ci/e2e/scripts/run_ocpp_tests.sh b/.ci/e2e/scripts/run_ocpp_tests.sh index 8af581308c..905626a7e7 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" -python3 -m pytest \ +pytest \ -rA \ -n "$PARALLEL_TESTS" \ --dist=loadgroup \ diff --git a/CMakeLists.txt b/CMakeLists.txt index b1abcc352c..f412d67ef6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,7 +21,7 @@ if (NOT everest-cmake_FOUND) FetchContent_Declare( everest-cmake GIT_REPOSITORY https://github.com/EVerest/everest-cmake.git - GIT_TAG v0.6.0 + GIT_TAG main ) FetchContent_MakeAvailable(everest-cmake) set(everest-cmake_DIR "${everest-cmake_SOURCE_DIR}") diff --git a/modules/EnergyManagement/EEBUS/ConfigValidator.cpp b/modules/EnergyManagement/EEBUS/ConfigValidator.cpp index 8739f04d5d..92994f72dd 100644 --- a/modules/EnergyManagement/EEBUS/ConfigValidator.cpp +++ b/modules/EnergyManagement/EEBUS/ConfigValidator.cpp @@ -72,11 +72,11 @@ std::string ConfigValidator::get_serial_number() const { } int ConfigValidator::get_failsafe_control_limit() const { - return this->config.failsafe_control_limit; + return this->config.failsafe_control_limit_W; } int ConfigValidator::get_max_nominal_power() const { - return this->config.max_nominal_power; + return this->config.max_nominal_power_W; } bool ConfigValidator::validate_eebus_service_port() const { @@ -180,7 +180,7 @@ bool ConfigValidator::validate_serial_number() const { } bool ConfigValidator::validate_failsafe_control_limit() const { - if (this->config.failsafe_control_limit < 0) { + if (this->config.failsafe_control_limit_W < 0) { EVLOG_error << "failsafe_control_limit is negative"; return false; } @@ -188,7 +188,7 @@ bool ConfigValidator::validate_failsafe_control_limit() const { } bool ConfigValidator::validate_max_nominal_power() const { - if (this->config.max_nominal_power < 0) { + if (this->config.max_nominal_power_W < 0) { EVLOG_error << "max_nominal_power is negative"; return false; } diff --git a/modules/EnergyManagement/EEBUS/EEBUS.hpp b/modules/EnergyManagement/EEBUS/EEBUS.hpp index 4ee9a6ef13..a062799950 100644 --- a/modules/EnergyManagement/EEBUS/EEBUS.hpp +++ b/modules/EnergyManagement/EEBUS/EEBUS.hpp @@ -38,8 +38,8 @@ struct Conf { std::string device_brand; std::string device_model; std::string serial_number; - int failsafe_control_limit; - int max_nominal_power; + int failsafe_control_limit_W; + int max_nominal_power_W; }; class EEBUS : public Everest::ModuleBase {